Factory pattern added for using page objects.

The idea here is to provide a mechanism that instantiates page objects by using a simple factory approach. The idea for this is to allow code to take on a very common structure, making it easy to review and easy to build automatic checkers for. This approach is also nice for indicating workflows in a browser application.

There are two factory methods: on_view() and on().

The on_view() factory simply creates the page instance and uses the load() method to bring that page up in the browser. The on() factory creates the page instance but does not need to bring up the page in the browser since it's assumed the relevant page is already in view.
This violates the single responsibility principle.  The `on_view` method is delegating its own responsibility to the `on` method.  It would be better to contain this logic within the `on_view` method itself rather than injecting dependencies here.

Also, the `if` statement above is calling the same code as the end of the same method and immediately returning, which is an indication that something is wrong here.

```ruby
  def on_view(definition, &block)
    set_active(definition)
    @active.load
    call_block(&block)
  end

  def on(definition, &block)
    set_active(definition)
    call_block(&block)
  end

  private

  def set_active(definition)
    @active = definition.new unless @active.is_a?(definition)
  end

  def call_block(&block)
    block.call @active if block
    @active
  end
```