Added support for boosting query

See <http://www.elasticsearch.org/guide/reference/query-dsl/boosting-query.html>

Closes #445
Allow passing `routing`, `fields` and `preference` URL parameter to Index#retrieve

See <http://www.elasticsearch.org/guide/reference/api/get.html>

Closes #484
Added `type` restriction for Tire::Model::Persistence `all` and `first` finders

Closes #489
Added the `facet_filter` DSL method

With this patch, you can now define the `facet_filter` option for facets
via a DSL method.

So this:

    Tire.search('articles') do
      facet 'tags' do
        terms :tags
        facet_filter :range, { :published_on => { :from => '2011-01-01', :to => '2011-01-01' } }
      end
    end

is equivalent to this:

    Tire.search('articles-test') do
      query { string 'tags:ruby' }
      facet('tags', :facet_filter => { :range => { :published_on => { :from => '2011-01-01', :to => '2011-01-01' } }  }) do
        terms :tags
      end
    end

Closes #467
Added the `--data-binary` curl switch in Index#bulk_store

Closes #452
[TEST] Added integration tests for `page/per_page` style of pagination

Previously, tests for page/per_page style of pagination were implemented only fo the
"simple" searches in ActiveRecord integration.

This patch adds tests for "block" searches as well -- you can use this style of
pagination as well:

    s = Article.search page: 1, per_page: 5 do
      query { string 'foo' }
    end

Fixes #463.
[FIX] Remove `page` and `per_page` from parameters sent to elasticsearch
[FIX] Remove the `wrapper` options from URL params sent to elasticsearch

Also provide facility to remove other Tire specific options from URL params
[¡BREAKING!] Change format of sort/order in simple model search to <field>:<direction>

Makes it more consistent with the `sort` option [http://www.elasticsearch.org/guide/reference/api/search/uri-request.html]
[REFACTORING] Extracted logic in `Tire::Results::Collection#results` into separate methods

Refactored the ugly ~ 50LOC mess in `Tire::Results::Collection#results` into separate methods:

* __get_results_without_load
* __get_results_with_load
* __find_records_by_ids

This not only makes the codebase cleaner, but also provides hook points for people
who need to customize eg. the loading behaviour for Activerecord, where something like:

    def __find_records_by_ids(klass, ids)
      @options[:load] === true ? klass.find_all_by_id(ids) : klass.find_all_by_id(ids, @options[:load])
    end

prevents `RecordNotFound` exceptions on missing records (and other scenarios).

Fixes #343, fixes #485.
[#496] Allow building the search request step-by-step in Tire's DSL

This patch builds upon timon/tire@3ed3cdce3da7682e80eac7b93299902f5e427f2b by @timon.

Closes #496
[#496] [FIX] Fix bug in "step-by-step" building of query in Tire DSL
Use single quotes in `to_curl` commands to prevent shell expansion
Simplify the `pretty` URL parameter for `to_curl` output
Added accessor for Tire::Search::Query#value
Added a `match` query type

The `match` query is the most convenient way of exposing a search feature to end-users.

It automatically matches field analyzer with query analyzer, builds a corresponding query,
allows for "as you type" search with the `phrase_prefix` option, etc.

Tire exposes a single DSL method to use the query:

    Tire.search 'people' do
      query do
        match :last_name, 'Smith'
      end
    end

To search in multiple fields (with the `multi_match` query), just use a list of fields as the first argument:

    Tire.search 'people' do
      query do
        match [:first_name, :last_name], 'John'
      end
    end

You may want to give different fields specific boost with the caret notation:

    Tire.search 'people' do
      query do
        match ['first_name', 'last_name^10'], 'John'
      end
    end

The `match` method can be invoked repeatedly, in which case Tire will build a `must` boolean query automatically,
allowing you to quickly create "compound" queries working across multiple field types.

So, the following query:

    Tire.search 'people' do
      query do
        match :last_name, 'John'
        match :age, 30
        match :gender, 'male'
      end
    end

is equivalent to this explicit boolean query:

    Tire.search 'people' do
      query do
        boolean do
          must { match :last_name, 'John' }
          must { match :age, 30           }
          must { match :gender, 'male'    }
        end
      end
    end

See:

* http://www.elasticsearch.org/guide/reference/query-dsl/match-query.html
* http://www.elasticsearch.org/guide/reference/query-dsl/multi-match-query.html
[TEST] Added unit tests for the `match` query type
Extracted the magic number value for default `per_page` in Tire::Results::Pagination
[#463] Added test for the bug where you have to include `per_page` in model searches

If you don't specify a `per_page` option then the `page` option has no effect.
[#463] Use the Tire::Results::Pagination::default_per_page value in model search integration

Previously, without a `per_page` option, the `page` option was quietly ignored,
see failing test in karmi/tire@547feca.

With this change, you can pass just the `page` to the search:

    Article.search params[:q], :page => params[:page]

Closes #463.