Try for Nested List Shape

Hi.

This work is for Nested List Shape

You can't use this feature as like below.
```
  List(1, "hi", 1.2)
```
Above is possible using `HList` as like below.
```
  1 :: "hi" :: 1.2 :: HNil
```
But, you can use this feature for basic pivoting like below.
```
    def col(group: Column[Int]): List[(Int, Column[Int])] = {
      1.to(10).map(i => (i, score.filter(x => x.group === group && x.score === i).map(_.id).countDistinct)).toList
    }
    val queryOne = Query(0).union(Query(1)).
      map(t => (t, col(t))).
      filter(t => true.bind === true.bind). // to introduce sub-query.
      map(t => (t._1, t._2, t._2.map(x => x._2).reduceLeft(_ + _))).
      sortBy(t => t._1)
```
As unusual example, below is possible.
```
    def query(n: Column[Int], n2: Column[Int]) = {
      Query(List(List(List(1, 2).map(_.bind.asColumnOf[Int]) ++ List(n)))).
        map(x => x.map(x => x.map(x => x.map(x => x + 1).map(x => x + n2))))
    }
```
I don't think that this feature is useful on usual cases.
But, If there are repeated calculations like above example, I think that this is something useful.

There are a one limitation. You can't use this as `JDBC preparedStatement`'s parameter.
For example, below is not possible.
```
    def query(list:List[Column[Int]]):Query[...] = { ... }
    Compiled(query _).apply(List(1)).run
```
When compiling the query, parameter count is fixed. So, you can't change parameter count after Slick Query Compiling.

By the way, I couldn't find a way to make `ListShape` to default implicit shape.
So, in order to use this feature, you should use `ListShapeTrait`.
If you know how to fix this, please tell me.

Thanks.