Preserve return value in MiniTest example

The return value of MiniTest::Unit::TestCase is significant and needs
to be returned in order for the test reporter to work properly.

I also added an example for overriding the base implementation instead
of doing it in a subclass.
Add a couple additional testing examples (Fixes #522)
Require the core extensions when migrating

This doesn't currently matter, but as the core extensions will be
removed in the next major version, it's best to make the change
now so it isn't forgotten.

Basically, old migrations may rely on the core extensions, and
Sequel tries hard not to break old migrations.
Allow custom registered array types in the pg_array extension to take a :type_procs option

This will be used to handle per-Database instance registered types.
Support :typecast_methods_module when registering custom array types

This should make it possible to register custom array types on
a per-Database instance without affecting global state.

The singleton define_array_typecast_method moves from DatabaseMethods
to PGArray, and is now private.  That's a backwards incompatible
change, but it's unlikely anyone is relying on it.
Capitalize WHERE when parsing named types in the postgres adapter
Add support for PostgreSQL row-valued types

The adapter specs for these were all interrelated, so it was
easiest to combine them all into a single commit.
Cleanup PG_TYPES in the specs

These specs register types in PG_TYPES, a global constant, which
can cause failures in other specs.  Reset PG_TYPES after the spec
runs to avoid the issue.
Add documentation for :type option when creating columns (Fixes #524)
Use better example data in pg_row RDoc
Don't require pg_array extension when loading pg_row

I originally planned to make it automatic so that composite
types in bound variables would work.  However, since the
Database needs to be extended with a module, just loading
the pg_row extension will not ensure that.  The user needs
to manually load the pg_array extension first.
Add the type oid to the column schema on PostgreSQL

This can be used to take a column and string and cast the
string to a database type, the same way the native postgres
adapter does when retrieving the column.
Make all postgres adapters store conversion procs

Instead of just being used by the native postgres adapter, now
all adapters that connect to PostgreSQL have conversion procs.
This makes it easier for the pg_* extensions to work with any
of the adapters.

In the native postgres adapter, instead of copying connection
procs on first connection, do so upon initialization.  This
is less racy, more correct, and results in simpler code.  Note
that it won't actually check out a connection upon
initialization unless it needs one to do a name->oid mapping.

Cleanup some shared initialization code by adding an
initialize_postgres_adapter private method.

Change the private get_conversion_procs method to no
longer accept an argument, so modify callers appropriately.

While here, update the mock postgres adapter to setup sqls
data structure early, so that it works with these changes.
Also, have it implement the bound_variable_arg method, so
some postgres specs don't need to add it manually.

Also, rename convertor to converter in pg_array spec and
some rdoc.
Add pg_typecast_on_load plugin for converting advanced PostgreSQL types on load the {jdbc,do,swift}/postgres adapters

This allows the do/postgres, swift/postgres, and jdbc/postgres
adapters to handle the custom types similarly to how the
native postgres adapters handles them.  Currently, the typecast
on load plugin could be used, but that will soon not be possible
for some types.
Don't allow model typecasting from string to postgres array, hstore, or composite types

User input for typecasting is very unlikely to come in a String
in PostgreSQL output format. The only reason a string was allowed
before was to allow the do/postgres, swift/postgres, and
jdbc/postgres adapters to work with the typecast_on_load
plugin.  Now that the pg_typecast_on_load plugin has been added,
this feature is no longer needed and should be removed.

The parsers for these types were written expecting it only to
be called with database output.  However, typecasting is called
with user input.  I don't know of any vulnerabilities in the
parsers, but as they weren't designed with security in mind,
it's better to protect them from user input.  At the very least,
the pg_array parser without sequel_pg is quite slow, so for large
input it's an easy DoS target.

Other types such as interval, inet, range, and json have much
simpler parsers that shouldn't pose any security issues, plus it's
conceivable that input could come in the form of a string for
those types.
Reuse existing timestamp conversion proc

Instead of creating a new one via a method, reuse the existing one.
This saves on memory and is more correct in the case a custom
conversion proc for timestamps is used.
When loading multiple pg_* extensions via Database#extension, only reset the conversion procs once

Before, the conversion procs would be reset for every extension,
instead of only once.  This wasn't usually a big deal before,
but with pg_row and pg_hstore, reseting the conversion procs
requires database access, so it's best to eliminate the
redundant queries.
Don't do a runtime check for conversion proc for string types in pg_row

If a member of a composite type is a string type, then don't setup
a runtime check for a conversion proc, since that could hurt
performance.
Add Model#to_hash as an alias to Model#values

Since Sequel::Model is designed to be a wrapper around Hash that
adds some behavior, I think it makes sense to have a to_hash method.
Don't load schema, hook_class_methods, or validation_class_methods by default in specs

Since they were split from the base model support in Sequel 3.0,
the plugin specs loaded them globally into the Sequel::Model
class.  That's a bad idea, as it could hide dependencies in the
specs.  Make the specs behave better by only adding the plugin
to a Sequel::Model subclass.