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).