Test the do_* methods on the DB.

The easiest way to do this is to reuse the QS tests, which means fudging
the loading of t/QS.pl so a statement like

    query foo => ...;

will be recorded in a hash instead of installing a method. This is a bit
more tricky than I really like in a test; it might be better to make
t/QS.pl hold a data structure in the first place and then generate the
code from there.
qw() no longer provides implicit parentheses.

I don't really know why not...
Test interactions with DBIx::Connector.
Replace exp_require_ok with string eval.

This means the t::DB modules will load normally, which is required for
Cat testing.
Empty driver test file.
Catalyst tests.

Since we need to reload the Cat app several times with different
settings, this forks a subprocess we can throw away when we've finished.
This means passing the test results back to the parent and feeding them
into Test::Builder, which is not entirely straightforward. I should
either separate t::Util::Subproc into a separate Test::TAP::Passthrough
module (with its own tests) or possibly derive null subclasses of t::Cat
so each can run config/setup separately.

Fix a minor bug in Model::Irian: not specifying the DB gave a *very* odd
error message.
Docs for the Cat model and :via(Logger).
Make ROW tracing less chatty.

Stop printing the column names for every row, and introduce a new COL
trace category for the compile-time column definitions.
Support retrying serialisable transactions.

This requires two levels of retry logic: one inside DBC, to retry if the
connection drops, and one here to retry serialisation failures. It also
needs a new 'txnmode' config parameter, specifying isolation levels and
so on.

Obviously most of the actual work has to happen in the driver. I've
tried to at least gesture in the direction of making this generic: the
Driver base class supports read-only txns by setting the ->{ReadOnly}
DBI attribute; this means we need a mechanism to reset any such settings
at the end of the txn. (Pg forgoes this in favour of issuing SET
TRANSACTION directly, since the latter will be rolled back by the
database.) The driver is allowed to retry given any error it thinks it
can recover from; currently the only error Pg will retry is
serialisation failure.

Retrieving the SQLSTATE is also a little tricky. The only right thing to
to is to use something like Exception::Class::DBI, to catch the DBI
variables at the point where the error is thrown: otherwise if anything
in the stack-unwind makes any DBI calls the information in the dbh will
be invalid. However, I don't want to force people to use ECDBI, not
least because it's kinda heavyweight, so I provide three alternatives:
use plain RaiseError, and pray the handle status is still right; use a
HandleError which throws a specified ECDBI-compatible exception class;
or supply an arbitrary coderef to extract the DBI statusses from the dbh
and the exception.