Fix type error in benchmarks

Add documentation for public iterator structs

Rephrase description of `ChronofoldError`

Remove obsolete dependency

Stop using `serde(flatten)` due to a bug in serde

see https://github.com/serde-rs/serde/issues/1638

Remove trait bounds on public structs

This way they don't have to be repeated everywhere the type is used.
See also https://github.com/rust-lang/rust-clippy/issues/1689 .

Lift the requirement to implement `Clone` for `T`

Lift the requirement to implement `Debug` for `T`

Add tests for the length of serialized representations (JSON)

Optimize using sparse maps, consecutive inserts and serde magic

As expected, the document size decreased significantly:

[B1.1] Append 1000 characters (docSize):
       36787 bytes -> 4131 bytes
[B1.2] Insert string of length 1000 (docSize):
       36787 bytes -> 4131 bytes
[B1.3] Prepend 1000 characters (docSize):
       37896 bytes -> 23895 bytes
[B1.4] Insert 1000 characters at random positions (docSize):
       36546 bytes -> 24716 bytes
[B1.5] Insert 1000 words at random positions (docSize):
       237503 bytes -> 56116 bytes
[B1.6] Insert string of length 1000, then delete it (docSize):
       68678 bytes -> 45011 bytes
[B1.7] Insert/Delete 1000 strings at random positions (docSize):
       194584 bytes -> 115134 bytes

The overall performance regressed (again as expected) and will be subject of
further optimizations:

[B1.1] Append 1000 characters (time)
                        time:   [14.359 ms 14.453 ms 14.550 ms]
                        change: [+249.53% +251.63% +253.98%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 1 outliers among 100 measurements (1.00%)
  1 (1.00%) high mild

[B1.2] Insert string of length 1000 (time)
                        time:   [8.1027 ms 8.1550 ms 8.2109 ms]
                        change: [+224.48% +226.66% +229.35%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 7 outliers among 100 measurements (7.00%)
  7 (7.00%) high mild

[B1.3] Prepend 1000 characters (time)
                        time:   [46.924 ms 47.422 ms 47.972 ms]
                        change: [+1269.1% +1285.7% +1302.4%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 4 outliers among 100 measurements (4.00%)
  1 (1.00%) high mild
  3 (3.00%) high severe

[B1.4] Insert 1000 characters at random positions (time)
                        time:   [63.215 ms 63.795 ms 64.405 ms]
                        change: [+1413.8% +1428.0% +1442.7%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 2 outliers among 100 measurements (2.00%)
  2 (2.00%) high mild

[B1.5] Insert 1000 words at random positions (time)
                        time:   [1.8047 s 1.8250 s 1.8472 s]
                        change: [+1311.6% +1328.6% +1346.0%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 8 outliers among 100 measurements (8.00%)
  6 (6.00%) high mild
  2 (2.00%) high severe

[B1.6] Insert string of length 1000, then delete it (time)
                        time:   [8.7868 ms 8.8210 ms 8.8610 ms]
                        change: [-25.841% -25.475% -25.062%] (p = 0.00 < 0.05)
                        Performance has improved.
Found 5 outliers among 100 measurements (5.00%)
  3 (3.00%) high mild
  2 (2.00%) high severe

[B1.7] Insert/Delete 1000 strings at random positions (time)
                        time:   [999.11 ms 1.0061 s 1.0138 s]
                        change: [+775.99% +781.96% +789.03%] (p = 0.00 < 0.05)
                        Performance has regressed.
Found 5 outliers among 100 measurements (5.00%)
  4 (4.00%) high mild
  1 (1.00%) high severe

Add "B1: No conflicts" benchmarks

See https://github.com/dmonad/crdt-benchmarks .

Bump version

Add license file

Fix `iter_newer_ops`, remove incorrect optimization for now

Remove debug output

Add `last_index`

Add `Version` (vector clock)

Remove unused dependency

Derive `PartialEq` and `Eq`

Return ownership of op in `apply` in case of error

This enables storing of "pending" ops without having to clone them.