Implement lazy associations

**This feature is under development, will rebase at will.**

Currently we only support nested objects. While this is a significant advantage when it comes to using a document oriented storage solution like ArangoDB, there are still a lot of use cases where this approach doesn't fit. For those cases we need some good old associations:

Obviously they are kinda different from what one know when using ActiveRecord. Due to this we decided to not call them the same way. We will go with the following naming:

 * `references` - references a single model
 * `referenced_by` - references a list of other models (all of the same class)

Associations must be declared at two points: The model class **and** the collection class. In the model class you just define an appropriate attribute and in the collection class you define the persisted reference. Due to this just looking at the model will not reveal any associations realized on database level (you could imagine defining an 'association' to a simple value object and not a dedicated model class).

The following code outlines the desired API design:

```ruby
class Post
  include Guacamole::Model

  attribute :author, Author
end

class Author
  include Guacamole::Model

  attribute :posts, Array[Post]
end

class AuthorsCollection
  include Guacamole::Collection

  map do
    referenced_by :posts
  end
end

class PostsCollection
  include Guacamole::Collection

  map do
    references :author
  end
end
```

There are somethings we should take care during the implementation:

 - [x] Ensure we do not end up with circular dependencies when defining models
 - [x] Ensure we are not running in some infinity loops when fetching the data and resolving the dependencies

The first will likely be solved with autoloading (at least for Rails projects). For the latter we will need to introduce some kind of proxy objects.