Speed up Sequel.split_symbol 10-20x by caching results

Chances are, if a symbol needs to be split once, it needs to
be split more than once, so caching previous results should
significantly improve performance.

There is no cache expiration for this cache.  I don't think there
is a denial of service risk, as creating arbitrary symbols is
already a denial of service risk on ruby < 2.2, and even on ruby
2.2+, creating symbols from user input is a bad idea from a
security perspective.

From my testing, this speeds up dataset literalization by about
80% for some common datasets.  Unlike the previous commit, this
speedup does not drop as the dataset gets more complex, though
it does vary depending on the ratio of symbols the dataset has
to literalize versus other objects the dataset has to literalize.
Don't clone a Database object in the specs
Speed up Dataset#literal for symbols 60% by caching results, speeding up dataset literalization up to 40% or more

While splitting symbols was the more expensive part of
literalization, mangling and quoting isn't cheap either,
so caching the resulting literal output is a big
performance win.

Unlike the split_symbols case, how symbols are literalized depends
on both per-Database and per-Dataset settings.  Cache the literal
symbols in the Database object, don't use the cache if the
Dataset has overridden the Database's default settings or a
prepared statement is being used, and clear the cache if the
default settings change.
Reduce computations inside Sequel.synchronize blocks

Sequel.synchronize uses a single, global, non-recursive mutex,
and should only be used to protect access to data structures
(usually hashes).  It is very important that all computations
be done outside Sequel.synchronize blocks, and that inside the
blocks you only access local variables (or attr_reader methods).

A few places in Sequel, these principals were violated.  This
caused a recursive mutex error when removing cached schemas or
using columns_introspection on ruby implementations that don't use
a GVL.

This removes Model._descendants private method from the subclasses
plugin, and dups each subclass array instead of holding the mutex
while transversing.  Those additional allocations hurt performance,
but it isn't generally used in performance sensitive code, and it
is much worse to lock the mutex for an arbitrary amount of time.