Make filter by associations support use column references and method references correctly

When the column reference and method reference were split previously,
the regular loading and both types of eager loading were updated
to handle them correctly, but the filter by associations code was
not.  Make the changes to the filter by associations code so that
it handles column references and method references correctly.

In order for the filter by associations code to work with both
model instances and model datasets, you need to use different
parts of the reflection (method parts for the instance, column
parts for the dataset), so handle that correctly.

Add specs for this, and start testing for specific SQL in the
column reference versus method reference spec.  Also add
integration tests for filter by associations with keys in
PostgreSQL hstore columns.

While here, make the AssociationReflection#qualify method only
qualify Symbols and SQL::Identifiers, so it doesn't negatively
affect other expressions. A consequence of this is that
:predicate_key should never be needed to be set manually, you can
just set the regular option (such as :key), and if it is an
expression, it will work correctly.  Because it shouldn't be
necessarily to set :predicate_key manually, stop documenting it
and remove the mention from the CHANGELOG.

To make the implementation easier, setup some additional hash
entries when associations are defined.
Do deep qualification for non-column expressions in association keys

If a Sequel expression is given as an association column reference,
use the Qualifier AST Transformer to attempt to qualify internal
parts of it.

Without this, such expressions don't get qualified, which can lead
to issues later if joins are done manually.  Note that this does
not completely fix the issue, as the implicit qualification when
joining does not do deep qualification (yet).
Attempt to correctly qualify expressions when joining in model association datasets

This adds the :qualify=>:deep option to Dataset#join_table, which
reuses the Qualifier ASTTransformer subclass to qualify subexpressions
of expression objects given as keys/values to conditions.  Previously,
join_table just automatically qualified Symbols, now it can handle
many more types of objects.

Use this new feature in model associations, so you can provide an
unqualified expression as a column reference, and it will be qualified
correctly in all cases where it is used.  Update the specs to reflect
the new qualification. Also, add specs for filtering by associations
with model datasets.

Use this new feature to simplify the PostgreSQL hstore association
definitions, eliminating the manual qualification and the need for
:graph_only_conditions.

Because it's simple and some people may want it, also support a
:qualify=>false option in #join_table, which will skip all
qualification.
Make many_through_many associations handle expressions instead of column references

When the column reference versus method reference distinction was
added, only the default associations got updated, many_through_many
associations did not.  Rectify that by supporting many_through_many
associations the same way as many_to_many associations, using
:left_primary_key_column and :right_primary_key_method.

To support expressions in addition to plain column references, use
deep qualification in all joins.

Add some specs for this behavior, and some integration tests for
many_through_many with all the keys in PostgreSQL hstore columns.

While here, do some RDoc reformating for the many_through_many
method RDoc.