Make defaults_setter plugin operate in a lazy manner

Instead of setting defaults in the initial values hash, just
return them if the model setter method is called for new values.
Makes instantiation much quicker, but the values hash does not
contain the defaults.
Modify associations after fields in json_serializer and xml_serializer

Modifying it before doesn't work with autoreloading associations,
since a foreign key change will clear the associations.
Integrate many_to_one_pk_lookup and association_autoreloading plugins into main associations plugin

The many_to_one_pk_lookup plugin should give better performance,
and the association_autoreloading plugin should give more
intelligent behavior, so I think all association users should have
these two plugins loaded, which is why I'm integrating them into
the default support.

This integrates the code from the two plugins, but leaves the
empty plugin files out there, so that code that uses the plugins
explicitly will not break.  Eventually the usage will be
deprecated and removed.

The prepared_statements_association plugin now explicitly checks
for caching support in the associated class, and does not use
a prepared statement in that case.  The idea is if caching is
supported, it's faster to just use the cache instead of always
calling the prepared statement.  Before, you could load the
many_to_one_pk_lookup plugin after the
prepared_statements_association plugin to work around this issue,
but as many_to_one_pk_lookup is now integrated, the
prepared_statements_association plugin must have explicit support.

Disable using a primary key lookup in the sharding plugin, since
it doesn't support doing the lookup on the same shard.
Model#set_all and #update_all can now update the primary key

These methods are trusted, since they allow setting all
non-specifically restricted methods.  Note that unless you
are using the update_primary_key plugin, changing the
primary key for an existing record won't work by default.
However, setting the primary key for new records is a common
use case, and one that it makes sense to support via the
set_all method.
Model#save no longer calls #_refresh internally, deprecate Model#set_values

This separates the three types of set_values calls:

1) When loading objects from the database (Model.call)

2) When manually refreshing objects to discard existing changes
   (Model#refresh).

3) When automatically refreshing objects to get the default values
   for model columns (Model#save).

For some plugins, this causes three duplicated code paths, since
those plugins want the same behavior for each of these paths.

However, other plugins wanted different behavior for the three
paths, but since they used set_values, ended up with the same
behavior for each.

This changes the associations, composition, serialization plugins
to not clear cached values in case 3).  Any cached values should
not change in an after_save refresh, so clearing the caches just
caused more work in the database, and possible issues in the
application.

This makes the dirty plugin not clear cached values twice.

This adds the _refresh_set_values and _save_set_values private
methods to replace cases 2) and 3).  Case 1) doesn't have a method,
as Model.call just sets the instance variable directly in the
instance.
Update CHANGELOG