Optimize windowing and chunking function on series

This makes `Series.windowInto 10 Series.mean` about 5 times faster than previously.
Previously, the code was actually building index for each of the windows (by creating
an array of keys and then allocating a new index). This change implements
`LinearRangeIndex` which represents a virtual index over a subrange of a parent index
(thanks to immutability!) So, for the common cases like the above, we do not actually
need to allocate a new index.
Cleanup and reorder functions in the series module

This does not change any functionality or rename any functions. I mainly wanted
to group them in logical groups, so that we can more easily keep track of the naming
conventions used throughout the file and I added some comments that will be turned
into nice HTML documentation...
More systematic naming for ordering/sorting functions

Previously, we had `orderCols` and `orderRows`, but since all the new sorting functions
use "sort" in the name (which I think is a good idea) and there is a wide range of
`sortRows`, `sortRowsBy` and `sortRowsWith` functions (all well named), this commit
makes `orderRows` obsolete and replaces it with `sortRowsByIndex` (and similarly for
columns, to keep the symmetry).

I left the obsolete functions there to simplify migration, but marked them obsolete.
We can remove them in some future version.
Add some documentation and use C#-friendly generic type parameter names
Optimize resampling functions

This started by following the same idea as windowing/chunking functions
optimization (a2b24be1fb89b1f895b676eb4433dcbd23773669), but then I understood
that the implementation was not very good in the first place. So, after a few
failed attempts to understand and fix the `chunkedUsing` function, I realized
that we could make things simpler.

So, this removes `chunkedUsing` function (moving unit tests to work directly
on the series). The previous implementation of `Resample` iterated over the keys
and index, matching the required new keys with the existing keys and keeping
chunks. The new implementation just performs direct lookup to find all the new
keys and then calculates the ranges to be used by `LinearRangeIndex`. This is
between 5x to 50x times faster (see https://github.com/tpetricek/Deedle/commit/406ca914c9df4cdfbbdaa3ea8a491c97917a4a4e).

I also changed the definition of `Resample` (following the pattern used by
`Aggregate`) so that key-selector and value-selector are not separate and we
avoid allocating the series twice.

Oh, and this checkin also improves `TryGetRowObservation` from previous pull request.
Optimize frame.Rows (fix #165)

This makes `frame.Rows` about 4 times faster for a data frame with 1M of rows
(i.e. ~2600ms to ~600ms on my machine). The main change is to decrease the
number of objects that are allocated for each ObjectSeries and virtual vector.
In the new version, it is just two objects (one for the vector & one for the
series). Previously, the operation allocated a number of `ref` objects, `Lazy`
objects and one more `ref` caused by the code generated for `as this` in the
definition of `Series<T>`.
Merge pull request #168 from tpetricek/mainline

Mostly optimizations