MySQL is a bit more... lax with types than other backends. It's very
easy to accidentally get a 64 bit integer or decimal when other backends
would continue to give you a 32 bit integer. Right now we're relying on
conversion happening in `libmysqlclient` for `query_by_index`. If we
ever want to dump `libmysqlclient`, we will need to move those
conversions into Diesel.

However, I've opted to do this in such a way that it affects `sql_query`
as well. Right now there are many differences between what our query
builder says and what MySQL does. (32 bit addition/subtraction returns
64 bit, 32 bit multiplication/division/sum return decimal). Ideally you
should be able to have a struct that derives both `Queryable` and
`QueryableByName`, and have that work with the same query built using
the query builder or `sql_query`.

In order for that to happen, we can't do the conversions until we hit
`FromSql`, since for `sql_query` that is the first and only time we
learn what the expected type is.

Also add some links to relevant mysql/mariadb documentation there

Clippy (rightful) complained that we read from a potential unaligned pointer,
which would be undefined behaviour.
The problem is: Clippy continues to complain about this, even if we
use `read_unaligned()` here. This seems to be a clippy bug, see
rust-lang/rust-clippy#2881

mysql backend

This commit adds a fake type layer above the types exposed by the
mysql wire protocol as some of them are unused, can be used in the same
context and some additional information are required to be read from
the provided flags integer. I do not want to expose such a mess to
potential users, better expose an clear type enum with all currently
supported variants in diesel. If we hit later something that isn't
supported yet we can just add it with an additional entry, because
this enum is `#[non_exhaustive]`

This change fixes a out of buffer write in newer versions of
libmysqlclient. That write was caused by a change in libmysqlclient
around version 8.0.19 that added another field to `MYSQL_TIME` and by
diesel using a statically generated binding (mysqlclient-sys). As
consequence diesel would allocate a to small buffer for the struct
while libmysql writes more bytes that expected, which results in a out
of bound write. Interestingly this does not happen with a recent
libmysqlclient version based on the sources in the mariadb source
code.

As a fix I move an updated version of `MYSQL_TIME` to diesel itself, as I do not have any
control over `mysqlclient-sys`. This change is compatible with older
libmysqlclient versions, because for them we just allocate a larger
buffer than they actually use, which is fine.