Add :preconnect Database option for immediately creating the maximum number of connections

In some cases, connecting to the database can take a long time
even if there isn't high latency between the database and the
application.  In those cases, it would be nice to preconnect the
maximum number of connections on database initialization, reducing
the possibly of high latency during runtime.

For the sharded pools, this creates the maximum number of
connections to each shard.

Previously, this was possible to do manually (using a pair of queues
and an array of threads is one way), but even for the default
threaded pool it is tricky, and it's even trickier for the sharded
threaded pool.  This makes it a simple option to turn on.

For consistency and to make testing easier, make all connection
pools support a max_size method.  As the threaded pools already
supported this, this just adds a method that returns 1 to the
single connection pools.

This is being added as an option to the database instead of a public
method that can called anytime because allowing it to be called at
anytime would introduce race conditions or locking issues.  By
making it an option that is called before the database instance is
returned to the user, this should avoid such problems.
Minor ruby 1.8 fixes for sharded threaded connection pool

ruby 1.8 doesn't canonicalize require paths, resuting in the
regular threaded pool file beind loaded multiple times.  Fix
that by using require instead of Sequel.require, similar to
how the connection pool loads subclasses.

Just in case something weird occurs and the threaded connection
pool file does get loaded multiple times, add a guard around the
aliasing of the superclass method so it doesn't break the
sharded threaded connection pool.