Make identity_map plugin work with standard eager loading of many_to_many and many_through_many associations

This overrides the default :eager_loader implementations for
many_*_many associations so that they work with the identity_map
plugin.  The eager loaders used by the identity_map plugin could
be used generally, but they are slower, so I choose not to do that.

The eager loaders used by the identity_map plugin should work
correctly in almost all cases.  If the :eager_graph option is
used for the association, you need to set the :uniq option for the
association and the :cartesian_product_number=>2 option for the
association named by :eager_graph, otherwise you'll proably end up
with invalid duplicate associated objects.  If you do have
duplicate objects you want loaded, that won't currently work
correctly, and fixing it would require significant architectural
changes.  The probability of identity_map being used with a
many_to_many association that also uses :eager_graph is probably
remote enough not to worry about making such changes.
Add TinyTDS adapter to website index page
provide a more detailed error message when encountering restricted columns
Fix denial of service due to memory exhaustion from arbitrary symbol creation (Fixes #369)
Fix handling of nil values with the pure-Java version of nokogiri in the xml_serializer plugin

This is probably a regression in nokogiri compared to the libxml
version, but this new code works on both.  Also, the pure-Java
version seems to upcase the encoding attribute, but just change
the spec to use an upcased version as that isn't a big deal.
Fix literalization of Date, Time, and DateTime values on Microsoft Access
Update RDoc for Sequel::Model
Don't treat strings with leading zeros as octal format in the default typecasting

It's much more likely that someone will use '013' to mean 13
instead of 11, and raising an error for '08' is probably a bad
thing.  Still respect the 0x prefix for hexadecimal.

If anyone is relying on the old behavior, I'll be happy to add
an extension that restores it (similar to how the
looser_typecasting extension uses to_i and to_f).
Replace internal implementation of eager_graph with much faster version

In my testing, this is anywhere from 75% to 225% faster than the
previous implementation (which hasn't changed much since its release
in Sequel 1.5.0).  Before, eager_graph relied on graph_each to
split the hash into subhashes and turn each subhash into a model
object.  However, in many cases (unless you are only eager graphing
*_to_one associations), that is wasteful, as many of the instances
don't get used.

This new approach keeps the plain hash all the way through to the
eager_graph stage.  It uses the metadata provided by graph to parse
the hash into subhashes and create model objects, but only does so
if it is needed (i.e. the model object has not been seen before).
That's the primary strategic optimization.  I have also made numerous
micro-optimizations to reduce the number of method calls and hash
lookups.

Before, the loading was done purely in Dataset methods.  Now, there
is a new class called EagerGraphLoader that handles the specialized
loading.

This is backwards compatible except in the case where you call a
method other than all on the eager graphed dataset.  Previously,
you got a hash with table alias keys and model instance values,
like you would for a plain graph call.  Now, you just get a plain
hash.  I apologize to anyone relying on the previous behavior, but
I think the performance improvement merits breaking backwards
compatibility in this case, especially considering how unlikely it
is that people are relying on the behavior.

There's minor fallout from this change in the sharding plugin, and
significant fallout in the identity_map plugin, but this commit
includes fixes for the fallout in both cases.
Fix rare issue in the postgres adapter

I've only seen this happen once, where the ensure block raised an
exception because q was false.  This check should at least do no
harm.
Use hanna-nouveau instead of hanna as the RDoc template

mislav's original hanna only works on RDoc 2.3.  It's pretty much a dead
end development wise.  hanna-nouveau is a fork that works with modern
versions of RDoc (currently 3.8).

This uses hanna-noveau if a modern version of RDoc is used, and
should still retain backwards compatibility with really old versions
of RDoc.  I'm not sure if it works with newer RDoc if you don't have
hanna-nouveau installed, though.
Number all RDoc section titles in Dataset and Database classes

hanna-nouveau sorts by section title, so the RDoc will finally
display sections in a sensible order.
Major speedup in dataset creation

This takes the setting of the @quote_identifiers,
@identifier_input_method, @identifier_output_method, and @row_proc
out of Dataset#initialize and delays their initialization until
they are needed.  This makes dataset creation about 2.5x faster on
1.8 and 4.4x faster on 1.9, and dataset cloning about 40% faster
on 1.8 and 20% faster on 1..

The tradeoff is about a 33% decrease in performance of
input_identifier and output_identifier, which are not usually
called directly.  Overall performance decrease during literalization
is very small.  This is likely to be an overall performance benefit
for almost all Sequel code.
Various RDoc documentation improvements
Fix LocalJumpError when eager loading many_to_many associations with the identity_map plugin without an active identity map
Test the identity_map custom eager loaders both with and without an active identity map
Disallow eager loading via eager of many_*_many associations with :eager_graph option

This combination (eagerly loading via eager, :many_*_many
association, :eager_graph option), was supposedly supported
earlier, and even had specs (but no integration tests).  Well, the
specs had invalid SQL in them (referenced tables only used in
subqueries), so they could never work on a real database.

Since this apparently never worked correctly, I'm just removing
the feature.  Fixing it would complicate the EagerGraphLoader,
and probably make it slower, and as apparently nobody is using
the feature, there's no point to having it.  I'm open to adding the
feature back at a later point if someone submits a patch that uses
the correct SQL (not hard), fixes the the EagerGraphLoader to
handle it (also not hard, most of the code needed is being removed
in this commit), and includes a full integration test suite.

This feature was written before Sequel used integration tests, which
is why there were no integration tests for it.  I didn't actually
catch the problem with the SQL until writing the integration test
for it.

I don't think this causes any backwards compatibility issues, other
than you may get a Sequel::Error raised instead of a
Sequel::DatabaseError.
Fix bug in default connection pool if a disconnect error is raised and the disconnection_proc also raises an error
Allow :pool_class option to take a :symbol

This allows you to load connection_pool classes via
:pool_class=>:foo, as long as inside the
sequel/connection_pool/foo.rb file, you set
CONNECTION_POOL_MAP[:foo] = self.

No connection pool class currently uses this, but it's possible
nondefault connection pool classes will be added in the future,
and if so, they will need this.
Fix connection in mysql adapter with :port=>"1234"

This can happen if the connection information is stored in yaml.
When a connection string is used, the URI library turns the port
into an integer, but that does not happen if an options hash is
used directly, and parsing yaml to get an options hash will
generally result in string values.