[MODEL] Fixed the incorrect protection for existing model methods (such as `search`)

Due to the different scope in the `class << self`, the `respond_to?` condition always returned false,
even when the model had in fact defined the method in question (such as `search`).

Instead of using `respond_to?`, `self.public_instance_methods.include?` has been used.

The concrete example is eg. [Ransack's](https://github.com/activerecord-hackery/ransack) `search` method.

Closes #96
[STORE] Added the blank skeleton of the "elasticsearch-persistence" gem
[STORE] Added the Persistence::Repository module and client integration
[STORE] Added the default `Repository::Class` for convenience

Instead of:

    class MyRepository
      include Elasticsearch::Persistence::Repository
    end

    repository = MyRepository.new

you can do:

    repository = Elasticsearch::Persistence::Repository.new

The module function `new` returns an Elasticsearch::Persistence::Repository::Class instance.
[STORE] Added the `Naming` module

Provides getting Ruby class from Elasticsearch type and vice versa,
ID from the document (Hash), as well as setting the `klass`
for the whole Repository instance.
[STORE] Added the `Serialize` module

The repository uses two symmetric methods: `serialize` and `deserialize`
to convert documents when:

1. passing them to the storage,
2. initializing Ruby objects when retrieving documents from storage

Every repository can easily customize (overload) these methods,
to provide (de)serialization for complex use-cases, such as storing
PDF files or images in the storage.

See:

* https://www.braintreepayments.com/braintrust/untangle-domain-and-persistence-logic-with-curator
* https://github.com/braintree/curator/blob/master/lib/curator/repository.rb
[STORE] Added the `Store` module

The `Store` module saves and deletes the documents in Elasticsearch
via the `save` and `delete` methods.
[STORE] Added the `Find` module

The module provides method to find one or multiple documents and to
check for documents existence.

The methods return `deserialize`-d Ruby objects based on `klass` or
the document Elasticsearch `_type`.

Missing documents are kept in the resulting Array as `nil` objects.
[STORE] Added the `Search` module

The module provides an interface for getting objects from the repository
based on a search query.

The results are wrapped in the `Response::Results` instance, which
proxies methods to the `results` property.
[STORE] Added the DSL variant of `klass` setter method

So:

    reposistory.klass = Foobar

is equivalent to:

    repository.klass Foobar
[STORE] Added the methods from the "elasticsearch-model" gem

Included `Elasticsearch::Model::Indexing::ClassMethods` to support setting the index name and document type,
and to allow configuring the mappings and settings for the index.

See:

https://github.com/elasticsearch/elasticsearch-rails/blob/6f4a57a/elasticsearch-model/lib/elasticsearch/model/indexing.rb
[STORE] Refactored the `:index` paramter to use repository `index_name`
[STORE] Changed that `document_type` method returns `nil` when no `klass` is set
[STORE] Changed that the `Store` methods reflect that `klass` returns a Ruby class, not a string
[STORE] Added the `index` and `type` aliases for `index_name` and `document_type`
[STORE] Added, that `document_type` can set the document type for repository

Also available as `document_type="foo"`.
[STORE] Changed, that repository methods respect `document_type` when it's set

When the `document_type` is configured for the repository, it is used
in `save`, `delete`, `find`, etc method to set the `type` parameter
for the client.

When the `document_type` is not set, the old behaviour of inferring
from `klass`, `document.class`, etc. is preserved.
[STORE] Implemented the gateway pattern for the repository integration

To provide flexibility to the end-user, the integration of the "Repository" module
has been refactored to proxy all repository methods via a gateway.

This allows users to set up the repository in a custom class, with class methods, in a DSL-like fashion:

    class NoteRepository
      include Elasticsearch::Persistence::Repository

      klass Note
      index :my_notes

      mapping do
        indexes :title, analyzer: 'snowball'
      end

      client.transport.logger = Logger.new(STDERR)

      gateway do
        def serialize(document)
          super.merge(special: 'stuff')
        end
      end
    end

The bundled Repository class can be configured via a block passed to the initializer:

    repository = Elasticsearch::Persistence::Repository.new do
      klass Note
      index :my_notes

      mapping do
        indexes :title, analyzer: 'snowball'
      end

      client.transport.logger = Logger.new(STDERR)
    end

The repository methods can be accessed via the class or instance methods:

    NoteRepository.klass Note
    repository.klass Note
[STORE] Added, that `index_name` is inferred from the including class

    class NoteRepository
      include Elasticsearch::Persistence::Repository
    end

    NoteRepository.index_name
    => "note_repository"
[STORE] Added, that the repository class reflects the `:index` option

Also, when using the "shortcut" to create the repository, a default
name of `repository` is set.