Rebase topic/tuples-everywhere.

The original branch was quite old and the history too complicated, so
we're squashing it. These were the original commits:

commit f619963b4f07fdd1de5b6a95a30e1a9cc32879ef
Author: Stefan Zeiger <szeiger@novocode.com>
Date:   Fri Jun 7 13:00:05 2013 +0200

    Remove Projection at last.
    
    - MappedProjection is now a simple ColumnBase. It can be created from
      any shaped value.
    
    - Fix a bug in createResultSetMapping that affects SlickBackend with
      the new encoding.
    
    - TypedMapping is not Typed any more. Its type is computed during
      type inference so it can be properly rewritten as needed.
    
    - ColumnBase in general is not Typed any more.

commit ca72014edfb5105982e14f897e1ce405936dbd71
Author: Stefan Zeiger <szeiger@novocode.com>
Date:   Thu Jun 6 15:52:56 2013 +0200

    Use ProvenShape to implement shaped * projections

commit 826399aea5a7b3a96db952c3629a8ea4867ab625
Author: Stefan Zeiger <szeiger@novocode.com>
Date:   Tue Jun 4 14:00:55 2013 +0200

    Remove ~ features from Projections and add them to Tuples

commit 65197efaa4bdd30e18255b68222115292ebd40e4
Author: Stefan Zeiger <szeiger@novocode.com>
Date:   Thu Nov 22 18:44:42 2012 +0100

    Replace ~ by proper tuples in most places.
    
    It works but I think it makes things less consistent intead of more. We
    need a way to remove the Projection classes entirely, or at least allow
    tuples to be auto-converted in all common cases without needing ugly
    hacks like .shaped
Remove WithOp.

Apart from tables in the lifted embedding, all uses are switched over to
EncodeRef which gets the same result in a cleaner way without having to
clone existing objects. The WithOp implementation is now contained
directly in AbstractTable and exposed through the EncodeRef interface.
Disentangle lifted embedding tables from TableNodes.

An AbstractTable now has a nodeDelegate that points to a separate
TableNode object. AbstractTable does not extend TableNode any more.

The DDL statement builders still require Table objects from the lifted
embedding. Once we integrate type providers and the associated schema
meta model into master, we should provide access to the meta model
directly through a TableNode.
Complete separation of Nodes and Reps.

This removes all remaining cases of Reps being Nodes. Nodes will no
longer leak into the API and you do not need the lifted embedding to
create them.
Add query-based DDL and Insert APIs.

The new table model will not expose raw Table objects anymore, so it has
to be possible to perform all operations, including DDL manipulation and
insertion, through Query objects.

Note that the new model obviates the need for .shaped calls when
inserting into tuples of columns.
Introduce the new table model.

A table is now represented by a Query[Row, _], as it should be from a
type-level perspective. The Row type, i.e. the "Table object" needs
to be defined as a class whose constructor takes a special Tag (or any
user-defined function that does the same as the constructor) and the
basic TableQuery is constructed from such a function, not a concrete
instance of the Table class. Such a prototype instance still exists
internally to represent the raw table. New instances are created from
the prototype by calling the constructor function again with a new Tag.

- It is no longer necessary to clone Table objects, so the usual caveats
  (use only use defs, not vals; SI-3764) do not apply anymore.

- TableNothing and tableShape are not needed anymore. We can always
  infer the correct type of a TableQuery (thus avoiding SI-3346 in this
  specific case).

- The concrete implementation of Tag is hidden in TableQuery. It is not
  possible to create a raw table row instance accidentally. The implicit
  conversion that lifts a Table object to a Query is also gone, so there
  is no more danger of calling it accidentally on a bound table row.

Some functions like getting the DDL object or creating a finder are now
based on the TableQuery instead of the raw Table object (which is not
exposed to the user anymore).
Sprinkle some macro sugar on TableQuery.

Instead of "TableQuery(new Foo(_))" for the simple case where you have
a table class with a one-arg Tag constructor, you can now write
"TableQuery[Foo]". The original syntax is still available (and needed
for more complex constructor functions).

This is implemented by a simple def macro which is as future-proof as
possible so we can include it in the stable API. It does not refine the
declared return type or match on trees constructed by the compiler. It
should be possible to rewrite this as a black-box macro with quasiquotes
in the future.

Why not just do it at runtime? Apart from losing compile-time safety,
this only works if E is static, otherwise we cannot instantiate it
through Java reflection:

  def apply[E <: AbstractTable[_]](implicit tag: ClassTag[E]):
      TableQuery[E, E#TableElementType] = {
    val cons = tag.runtimeClass.getConstructor(classOf[Tag])
    apply[E]((tag: Tag) => cons.newInstance(tag).asInstanceOf[E])
  }