Create a new RelationalProfile for relational non-SQL data stores.

- Moving parts of JdbcTableComponent up into RelationalTableComponent.
- Moving many capabilities from SqlProfile up into RelationalProfile.

An initial version of the (yet to be written) HeapDriver should support
most relational features but it won't understand SQL or any other
text-based query language. Having a useful profile at that level should
allow us to write many TestKit tests in a way that makes them work with
HeapDriver.
TestKit refactoring to support non-JdbcDriver tests.

Now tests can depend on any supported profile and will only be run for
drivers that support the test's profile.

We need to upgrade to Scala 2.10.1-RC1 because of SI-6677.
Move QueryTemplate functionality up into BasicProfile.

BasicProfile now defines abstract types for parameterized and applied
queries that are pre-compiled by the driver, along with a standard
implementation.

Actually executing these queries is done through new implicit conversions
to QueryInvoker and QueryExecutor. This change makes the execution of
plain queries and parameterized queries symmetrical and allows the latter
to be defined in a profile- and driver-independent way.
Move Table and Sequence into RelationalProfile, DDL into BasicProfile.

DDL is abstracted into BasicProfile.SchemaDescription which provides
concatenation but no internal representation of schemas. The string
representation is added by the old DDL type which has been moved into
SqlProfile.

With DDL being available at that level, overriding Table in JdbcProfile
is no longer necessary, so the complete definition is now at the level of
RelationalProfile. Sequence is used in a similar way to Table, so we also
make it part of the cake at the RelationalProfile level.
Move more functionality up to Basic/Relational/SqlProfile.

An abstract SchemaDefinition type (for DDLs) along with DDLInvoker goes
into BasicProfile (which is debatable - we may want to split that up later
into a really basic profile which is only for querying and one that
provides write access to the data)..

ColumnType and abstract implicits for the standard Scala types go into
RelationalProfile. We can move it further up to BasicProfile later when
we have a clearer picture how non-tabular data structures should be
represented.

All QueryExecutor functionality goes into BasicProfile. I'm also removing
the special ToQueryExecutor workaround for SI-3346. Our standard .shaped
workaround is enough to cover this case.

The QueryCompilers for querying and inserting are also moved up to
BasicProfile.
Add insertion to BasicProfile.

This uses the new method names += and ++=, similar to Scala collections.
Advanced features like returning generated keys are not supported at
the level of BasicProfile.
Refactor code generator + insert compiler phases
First cut of HeapBackend + MemoryProfile implementations.

HeapBackend and MemoryProfile/MemoryDriver provide a simple in-memory
storage engine. They are mainly intended as a way to test the query
interpreter implementation and help with defining useful profile levels
and base implementations.

The main feature here is QueryInterpreter. It is still very limited in the
number of supported features but it's enough to run the first two test
cases (CountTest and AggregateTest) which have been converted from
JdbcProfile to RelationalProfile. The interpreter and the data structures
are not particularly optimised for performance. We should consider
implementing a compiler instead of optimising the interpreter in the
future.
Move BigDecimal support and ColumnType aliases up to RelationalProfile.

This allows us to execute all numeric tests from DataTypeTest against
RelationalProfile, so we split it into RelationalTypeTest and
JdbcTypeTest.
Make joins work in QueryInterpreter.

- Rewrite JoinTest to use RelationalProfile.
- The semantics of RangeFrom and zipWithIndex joins in the AST were
  rather strange. Changing RangeFrom to represent an (infinite
  non-terminating) Query consisting of consecutive Long values makes for
  much saner semantics.
- Use the new RangeFrom semantics correctly in Query.zipWithIndex and
  the resolveZipJoins phase.
- Implement AutoInc columns in HeapBackend (used by JoinTest).
- Implement explicit inner/left/right/zip/index joins in QueryInterpreter.
- Implement Option conversions in QueryInterpreter.
- Allow actual Scala null values in QueryInterpreter in case a
  non-nullable column has to be extended to contain null (as is the case
  when evaluating outer joins). This means we need to be able to handle
  null values in some cases.
Switch ColumnDefaultTest and ForeignKeyTest to RelationalProfile.

- Move assertTablesExist/assertNotTablesExist up to RelationalTestDB.
- Move O.DBType up to SqlProfile.
- Implement equality for ProductValue.
- Implement some new library functions in QueryInterpreter.
- Change the type encoding of most library functions, along with changes
  to OptionMapper. The previous translation scheme created operations of
  the base type and then option-lifted them (e.g. a: Column[Boolean] ===
  b: Column[Option[Boolean]] would become OptionApply(Apply[Boolean](…))).
  This is not a correct representation of ternary logic. Instead we now
  compute the option-mapped type and and use that directly as the result
  type of the operation (e.g. Apply[Option[Boolean]](…).
Split MiscTest into RelationalMiscTest and JdbcMiscTest.

- All misc. tests except the ones for "fake" nullability can run against
  RelationalProfile.
- The IfThen clauses in ConditionalExpr nodes were in reverse order for
  no good reason. Changing to declaration order.
- Support ConditionalExpr and Like in QueryInterpreter
Switch NestingTest and NewQuerySemanticsTest to RelationalProfile.

- Fix bug in RewritePaths: Eliminate duplicate column names from the
  type that gets generated for a table.
- Support *, Not and Union in QueryInterpreter.
- Use the real HeapTable column ordering instead of the computed type for
  a table in QueryInterpreter.
Switch PagingTest and PrimaryKeyTest to RelationalProfile.

- Add uniqueness checks to HeapBackend via hash indices.
Split up ScalarFunctionTest into Relational and Jdbc parts.

- Add support for lots of numerical and other scalar functions to
  QueryInterpreter.
- Beef up ScalaNumericType to support that better.
- Fix hierarchy of BaseColumnType in RelationalProfile
Switch UnionTest and TemplateTest to RelationalProfile.

- Support Library.In and QueryParameter in QueryInterpreter.
- Fix parameter passing bug when using QueryExecutor to run applied
  parameterized queries.
- Pass query parameters to QueryInterpreter.