Support merging of N series and speedup alignment functions (cf. #179)

I first thought I could just add merging of N series using a similar pattern
to the one that we were using for 2 series. This worked, but it was pretty slow.
So, in the end, this is a fairly major revision of how the "aligning" functions
work.

The key changes are in 'Common.fs'. Previously, the functions returned a single
sequence with keys and optional values containing old addresses. To build the
"relocate" command, we had to iterate over this repeatedly. I changed them to just
build relocation tables directly. So, the functions `Seq.align[All][Un]ordered`
now return new array with keys together with relocation arrays that are directly
passed to the `Relocate` vector construction (this removes quite a lot of overhead
and the new implementation is also more straightforward imperative code with
more predictable performance).

Although it now works for N series (`Seq.alignAll[Un]ordered`), I also kept functions
for just 2 series (named `Seq.align[Un]ordered`). These are generally faster and
they also support calculating intersections. At the moment, I kept Union/Intersection
to just work on 2 indices (we could generalize this in the future if there is need).

I also added one optimization in `ArrayVector.fs`. The above commonly creates vector
commands that look as `CombineN [ Relocate v1; Relocate v2; ..]`. Previously, we would
build all the child vectors (by allocating array and filling it according to the
relocation table). I added a special case that looks for this pattern and avoids creating
the temporary vectors (it creates vectors `v1`, `v2`, ... and then combines them
while handling relocations at the same time).

This makes things a lot faster - I will post some performance measurements to GitHub.

I have not done renaming in this checkin yet (as suggested in #179) but will do that next.

I also removed `LazyList.fs` which was not needed anymore.
Correctly propagate information about whether index is ordered (and add test coverage)
When creating frame from sorted series, return sorted frame; fix (#170)
Improve type conversion function (fix #177) and fix failing tests from previous

The `tryCastType` function should be more strict and perform casting.
The `tryChangeType` function should be more flexible and allow both
casting and conversions using `IConvertible` interface. This fixes
`tryChangeType` to also allow casting (which was omitted earlier).
Trying align using BinomialHeap instead of linear scan
Fix align error in BinomialHeap implementation
Fix off-by-one error in binomial heap implementation
Small formatting fixes, added comments
Addresses #185, cleaning up the Deedle statistics API.

* Deprecates statistics functions living on Series
* Adds stats functions for operating on Frame columns
* Fixes bug in expanding stats involving Seq.scan
GH #185, moved other statistics functions to separate module
Additional work on #185, mostly cosmetic refactorings

- move statistics functions out of SeriesModule
- remove statLevel
- combine applyLevel, flatten
- add applyLevelOptional
- add flatMapValues to Series
Small naming change, fixed project file for RProvider plugin.
Additional API cleanup per #185 - remove unnecessary applyLevel/flatten from frame, add NestBy to extensions
Fix NestBy extension signature
Separate out flatMapValues to flatten, add extension method
Turns out we need a Frame.applyLevel after all
Add a convenience non-generic float sum function to Stats
Fix equality on OptionalValue (fix #184)
Optimize 'shift' and 'diff' functions (fix #183)

Previously, these were implemented using floating window, which was terribly slow.
I added new basic operation to the index representing "shifting", so now we just
need to copy the data (skipping over the values that "drop out") and create a new
index (excluding the dropped out keys). I also added some documentation.

The performance improvement is orderds of magnitude (from seconds to milliseconds),
so I'm not attaching any specific numbers.

Aside, I also accidentally discovered https://github.com/BlueMountainCapital/FSharpRProvider/issues/77
(and made the test here more stable) and I improved the build script to avoid
running tests twice.
Remove unnecessary array allocation in Aggregate (close #178)

This makes a simple example where the series is not used about 25% faster.
(Not necessary a realistic scenario, but might be useful in some cases)