[scala] Refactor Scala RowList with self-types, for better inference and implicits (operation on ScalaRowList returning ScalaRowList, not core RowList which would be converted again on next operation).

```scala
// Before
val l1a: RowList1[String] = rowList1(classOf[String])
val l1b: RowList1[String] = l1a :+ "B" // convert on :+ ...
// but core type RowList1 is returned

// Now
val l1a = rowList1(classOf[String])
val l1b: ScalaRowList1[A] = l1a :+ "B" // convert on :+ ...
// and keep it as pimped Scala type
val l1c: ScalaRowList1[A] = l1b :+ "C" // no conversion required
```

Typesafe append operations are generated along with generated row lists, so append-row operation and related Row implicits are no longer required.

```scala
// Before
rowList3 :+ row3(a, b, c) // no supported due to inference issues

// Now
rowList3 :+ (a, b, c)
```
Remove useless internal Cell type
[core] Deprecates append-row operation on RowList, replaced by multivalue-append.
Prevents null inference issues.

```java
import acolyte.RowLists;
import acolyte.Rows;

// Before
RowLists.rowList2(String.class, Integer.class).
  append(Rows.row2("str", 1)); // now deprecated

RowLists.rowList2(String.class, Integer.class).
  append("str", 1);
```
Update documentation
[core] Support nullable flag for meta-data of row column.

```java
import acolyte.RowList2;
import acolyte.RowLists;

RowList2.Impl<String,Float> l1 =
  RowLists.rowList2(String.class, Float.class).
  withNullable(1, true); // First column is nullable

import acolyte.RowList;
import acolyte.Column;

Column<String> meta1 = new Column<String>(String.class, "a", true);

RowList2.Impl<String,Float> l2 =
  RowLists.rowLists2(meta1, RowList.Column(Float.class, "b"));

import static acolyte.RowList.Column

RowList2.Impl<String,Float> l3 =
  RowLists.rowLists2(Column(String.class, "a").withNullable(true),
    Column(Float.class, "b"));
```
[scala] Support nullable flag for column of row list