Improve association method performance by caching intermediate dataset

Previously, when getting an association dataset, it would always be
derived from the associated class, which can be an expensive
operation due to the number of dataset clones involved.  Additionally,
all association datasets are extended with a module, which resulted
in Object#extend being called at runtime, leading to a performance
decrease as method caches are cleared.

This commit starts caching the non-instance specific dataset in
the association reflection, so that when an instance requests a
an association dataset, much less work is necessary.

This increases association_dataset method performance by about 179%
and association method performance by about 29% on ruby 1.9 in my
testing.  However, that performance increase only affects
associations without a custom :dataset option.  Associations with a
custom dataset option are marginally slower with the new code.

This change should not have backwards compatibility issues, since
it only affects datasets without custom dataset options, and the
standard association dataset just uses filters/joins.  The spec
changes are just for reordering of conditions, since the
:conditions option is now applied to the dataset before the
foreign key filters.

While here, switch from using filter to where, since we always want
to affect the WHERE clause with association conditions.
Document that the eager_each plugin uses Object#extend at runtime
Allow the :dataset association option to accept the association reflection as an argument

This fixes the limitation of the previous commit, where custom
:dataset options could not benefit from the caching of intermediate
association datasets.  With this change, the :dataset proc can
accept an option, in which case it is passed the association
reflection, on which the associated_dataset method can be called.

This change has some minor backwards incompatibility.  The private
_association_dataset method (note preceding underscore) is no longer
defined, and the public AssociationReflection#_dataset_method method
is also no longer defined.
Increase virtual row performance by using a shared VirtualRow instance

I've thought about doing this for a while, but never got around to
it.  Basically, Sequel::VirtualRow instances are purely used for
DSL purposes, they are stateless.  Instead of creating new
instances everytime you want to evaluate a virtual row, use a
shared instance.  This improves performance up to 100% in the best
case, and about 30% in the typical case for something like {a > 1}.