Cleanup specs for some dataset methods

should_receive results in poor specs, and it's use elsewhere in
the specs should probably be eliminated

Removing the spec for with_sql_delete, new specs will be readded
shortly.
Refactor find_or_create specs

Change them to use a local mock database instead of trying to
set the fetched rows at the dataset level, needed for some
coming opimization work.
Add Dataset#with_sql_{each,all,first,single_value,insert,update} optimized methods

This methods take an SQL string and directly run it and return
results.  This is basically a much faster way to do:

  ds.with_sql(sql).{each,all,first,single_value,insert,update}

It's faster as it doesn't require cloning the dataset (a rather
expensive operation).

with_sql_delete already existed from earlier optimization work.
Add Dataset::PlaceholderLiteralizer optimization framework

Dataset::PlaceholderLiteralizer is a new class that allows one
to record the changes made to a given dataset with placeholder
arguments.  The resulting dataset is then literalized, with the
placeholder arguments recording the current offset in the SQL
string insteading of literalizing themselves into the string.

Using the offsets, the string is split into an array of fragments.
Using that array, you can then pass arbitrary arguments into the
loader, and it can build the SQL string just by simple string
concatenation.

This is about 3 times faster in generating the SQL, and since
generating the SQL is a good percentage of the time spent for
simple queries that only return one row (assuming a local database
connection), this can speed up such queries by about 50%.

There are corner cases that this framework can't handle, but it
handles the vast majority of cases that Sequel users are likely to
use.  This includes things such as knowing that strings passed
to where should be considered literal strings:

  def find(arg)
    where(arg)
  end
  find("s = 1")  # WHERE (s = 1)
  find(:s=>1)    # WHERE (s = 1)

as well as where you are using the argument on the right hand side
of a conditions specifier, where the operator used changes based
on the value of the placeholder:

  def find_by_id(arg)
    where(:id=>arg)
  end
  find_by_id(1)      # WHERE (id = 1)
  find_by_id([1, 2]) # WHERE (id IN (1, 2))

This framework is similar to but more flexible than prepared
statements, since the underlying SQL can change from call to call.
Add Model.finder for creating optimized finder methods using Dataset::PlaceholderLiteralizer

This makes it easier to use Dataset::PlaceholderLiteralizer for
models, providing a simpler API.  You just pass it a symbol for
a model class method that returns a dataset, and it will create
an optimized method that will do the given type of action (default
type is :first, for returning the first record).

Add a Model.first_where optimized method automatically at runtime,
and have Model.find, .first, and .first! call it if given a single
argument.  This can speed up these methods by about 50% for local
database connections.

To avoid creating a bunch of unnecessary objects, the
PlaceholderLiteralizer objects are created lazily on an as needed
basis.
Fix RDoc for some Dataset sql literalization methods

Most of these have been inaccurate since the append-only dataset
literalization change in Sequel 3.30.
Make emulated operators on some adapters use an append-only approach

This adds Dataset#complex_expression_emulate_append private method
to the core, which contains implementations of the emulated code for
the %, >>, <<, &, |, ^, and B~ operators that were previously
duplicated in 7 of Sequel's adapters.

This changes Dataset#complex_expression_arg_pairs private method
to return nested expression objects instead of already literalized
objects, which may break backwards compatibility for external
adapters that call the method.
Raise error if placeholder literal arg literalized into different string than dataset returns

This catches issues when a non-append only dataset literalization
method is used to build the SQL string.  Previously, it would
have probably resulted in invalid SQL fragments being used or
maybe even silent failure.
Actually optimized Model.first and .first!

Previously, the optimized methods weren't called because they were
overridden after being defined.
Update shared caching spec to mock differently

This mocks the returned rows at the database level instead of the
dataset level.  This is more robust as it doesn't depend on the
particular dataset being used.
Automatically optimize Model.[] when called with a hash
Automatically optimize Model.[], .with_pk, and .with_pk! for models with composite keys
Add documentation for how Errors#full_messages handles literal strings (Fixes #775)