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
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)
Merge pull request #1 from adamklein/mainline

Storing min using BinomialHeap instead of linear scan
Merge branch 'mainline' of github.com:BlueMountainCapital/Deedle into mainline
Merge branch 'mainline' of github.com:tpetricek/Deedle into mainline
Cleanup binomial heap and use it only when appending larger number of series.

I did some cleanup in the binomial heap code, but have not changed any logic
(and I added one simple FsCheck test to check that it works OK).

I did some performance evaluation and the binomial heap implementation is much
faster for large number of series - usually around 150 (regardless of their length),
but for smaller number of series, it tends to be 2x slower. So I left both
implementations in the codebase and added a function that chooses the right one
at runtime. This is not entirely nice, but it seems to give us the best perf!
Series.ofOptionalObservations should take option (fix #174)

Aside from the change, I also cleaned up some old code
(removed 'Series.Create' helper and instead pass current index & vector
builders from the frame or use 'IndexBuilder.Instance' statics as needed).
Also added some documentation while changing these parts of Deedle!
Add skip and skipLast to series and frames (close #173)

I also optimized the take and takeLast implementations. Rather than building
a list with new keys (which is slow for a lot of keys) and reindexing, we can
just use the 'GetRange' operation on vectors and slicing on ReadonlyCollection
that stores the keys.
Add unary minus for frame and series (close #169)

Also added some tests for other operations on series and renamed poorly named helper.
Merge pull request #181 from tpetricek/mainline

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