Add in-memory traversal for :through associations

If the :through association is loaded and its :source association
is also loaded, AR can retrieve has_one/has_many :through records
without querying DB.

```ruby
class Author
  has_many :posts
  has_many :comments, :through => :posts
end

class Post
  belongs_to :author
  has_many :comments
end

class Comment
  belongs_to :post
end

author = Author.includes(:posts => :comments).first
# previously `author.comments.to_a` would issue an additional
# redundant SQL query (to load comments again), now instead
# since both `author.posts` and `author.posts.comments` are
# loaded, AR is smart enough to traverse in memory object graph
# to avoid hitting DB. Essentially it will now do
# `author.posts.map(&:comments).compact`.
author.comments.to_a # this will now not issue an SQL query
```

I'm not that comfortable around this part of AR code a thorough review
by AR-association masters is in order :bowtie:. 
This would need to triple the amount of `super` in the method :):
```ruby
def get_records
  if proxies_assoc = get_through_proxy_assoc_if_loaded_and_not_stale
    if !(through_proxies = proxies_assoc.target)
      []
    elsif through_proxies.kind_of?(ActiveRecord::Base) # if SingularAssociation
      if target_assoc = association_if_loaded_and_not_stale(through_proxies, source_reflection.name)
        target_assoc.target
      else
        super
      end
    else # else CollectionAssociation
      try_get_records_from_through_proxies_collection(through_proxies) || super
    end
  else
    super
  end
end
```