Make sure we have SQLite 3.7.11 or higher.

That was the version where the VALUES clause gained the ability to insert more
than one row. We could instead use a UNION ALL subquery, like the Oracle
engine does, and we can if anyone really complains. For now, throw an error
if DBD::SQLite is built with an older version.

While at it, fix a typo in the error message when no SQLite database is
specified.
De-dupe list of missing dependencies.

Closes #97.
Skip SQLite test on unsupported versions of SQLite.
Update localization files.
Timestamp v0.973.
Stub out MySQL support.
Hammer out mysql basics.

Includes configuration, timestamp formats, etc.
Start live MySQL tests.

Connecting and checking for initialization work.
First cut at the MySQL schema.
Get fetcuing of eariest and latest change Ids working.

Requires overrideing _cid() to do the right thing according to MySQL's definition.
Get about a quarter of the MySQL live tests passing.

The changes to get this far include:

* The string for the `sql_mode` setting must have no spaces, only commas,
  between its values.
* Convert timestamps to UTC and send the value to the database in plain
  iso-8601 format (that is, without a time zone specification).
* Use `current_timestamp` for the default timestamp value.
* Make sure an error value exists before checking it.
* Make sure that LIMIT and OFFSET are on a single line (WTF MySQL?)
* Table-qualify all column names where "change" is included in the list of
  columns. This is becuase "change" is reserved by MySQL, but need not be
  quoted when it is table-qualified.
* Quote "change" in `INSERT INTO` statements, because MySQL is too dumb to
  realize that column names are unambiguously connected to a table name in
  that context. *Eye role*.
* Use the same Sqitch schema name (database) as is used in the other engine
  tests.
* Properly check MySQL error strings (not sure if it will bump into localized
  variations, though).

Next up, dealing with the fact that MySQL discards sub-second precision in its
timestamp values. (*Groan*)
Require MySQL 5.6.4+ for microsecond precision.

This makes it easier to track the order of things, and decreases the chances
of primary key violations when two changes are committed within a single clock
second.

Also, switch from TIMSTAMP to DATETIME so that we can keep things nice beyond
2038.
Skip tests on older SQLites and MySQLs.
Missed a few TIMESTAMPs.

Convert them to DATETIME(6)s. About half the live MySQL tsts pass now.
Get all live MySQL tests passing.

Required just a few additional minor changes:

* The MySQL docs actually recommend using a huge number to fetch search
  results from an offset with no limit. What*ever*.
* Fix the call to the `group_concat()` aggregate to actually do
  space-delimited concatenation.
* Table-qualify a couple of additional references to the column named
  "change".
* Add a function to the test to add a second to a datetime. This is because,
  like Oracle, the UTC_TIMESTAMP() function returns the statement time, not
  wallclock time.
Fix tag array sort order on MySQL.

The other databases default to using the row order for the agrregation order.
MySQL's `group_concat()`, alas, is random. One can specify an `ORDER BY`
clause for it, but since tags for a single change are inserted at the same
time, they have the same `committed_at` value, so that doesn't work. So we
just have the test force the order on MySQL and don't worry about it.

Also, set `group_concat_max_len` to 32768. I assume that should be enough
characters to represent most lists of things.
Test the MySQL connection configuration.
Test the SQLite foreign_keys pragma.
Test the Postgres search path.
Mention the MySQL support in the docs.