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.