Faster to_list: 20X for small Vectors and 8X for large ones

Custom implementation of to_list.
Recursively walk the trie in reverse order (to build the resulting list in the right order).
Adaptive strategy for prepending leaf blocks:
* for Vectors up to 3 levels deep (up to 32,768 elements) use Tuple.to_list and list concatenation
  (up to 1,024 temp lists created)
* for bigger Vectors use custom prepend one by one function as the overhead of creating and reverting
  lists becomes significant

More informative description.
Ability to run benchmark in `full quick` mode.

Small bugfix

v0.1.3

Fixed bug in reduce_root: first call to Enumerable.reduce can be with…

3X speed up of enumeration

PersistentVector enumeration was 1.5 times slower than Map.
Improved enumeration speed by doing it in 32-element leaf node chunks.
Now it's 1.9 times faster than Map.

Minor optimizations

Optimized order of `reduce` function overloads in Enumerable

Putting most common cases first to improve perf.

Benchmarks:
* Added comparison with Map
* Measure Enumerable perf
* Snapshot of latest results
* Added explanation why to compare with Map

First public release

v0.1.0

PersistentVector is an array-like collection of values indexed by con…