Return df.Columns as virtual boxed vector (fix #91), (related #100)

The df.Columns property now does not copy and box all data, but instead returns a
special type of vector that boxes values on the fly. When Frame.ofColumns is used,
it checks for this special type of boxed vectors and unboxes it to get the original
data.

This makes some things better (we can get df.Columns and perform some manipulation
on the returned series), but it does not help when you perform some manipulation on
the nested series (ObjectSeries), because that will still re-create the vector as
ArrayVector<obj>.
Check for boxed vectors in object series conversion methods

As a result, `df.Columns.["A"].As<float>()` is essentially no-op
when the column is of type float. Previously, this involved boxing & unboxing.
(For 1M elements, this is now ~0ms and used to be 250ms)
Remove reflection-based invoication on non-generic vectors

Rather than looking at ElementType via reflection and generating code at runtime,
this delegates the responsibility for making the generic invocation to the vector
itself. This is mainly refactoring (remove ugly reflection). This also removes
unused call site for 2 vectors and replaces call site for vector lists with a call
using a witness vector. In AppendN, this does the same thing as before - find first
vector and use it as a witness to get the static type (but doing this in a single
pass should be easier). The previous implementation was in line with what was there
originally (and so it was pretty nice!) - here I just tried to simplify the entire
"call site" stuff...
Add conversion to/from arrays (fixes #114, #99); refactoring and some comments

The conversion to array is done using `df.ToArray2D<T>` which is a generic method.
When the frame contains missing values then 1) for T=float or T=double we return
NaN automatically 2) for other T you have to use overload that takes default value.
In F#, `Frame.toArray2D` always returns `float` because that is likely the most
common use (for other types, function would look ugly).

This also adds some "XML" comments to a couple of other functions around.

I also moved the handling of `IBoxedVector` (74225ce54f094a6ee82cfc75e60c1da4751db2ba)
from `As<T>` to `changeType` function (which is used by `As` but also from other
places like the newly added conversion to arrays).
Adding unit test for passing decimals from/to R (fix #90 as no repro)
Switch R provider tests to 4.3.0.0 to match with Deedle
Cleanup row access functions in Frame

This reverts the API change accidentally caused by (dac7a76753c821ba6e7714a98e19ea466a9e226d), but
uses the same idea to keep the row access faster. The checkin also makes the API more uniform and
adds documentation. The pattern is `[Try]GetRow[At]` where `Try` means return `OptionalValue` and
`At` means lookup by index rather than lookup by row key. I actually removed `TryGetRowAt` because
that does not seem to be that useful (caller should make sure that they give us valid index) - but
I would be happy to add it back.

The checkin adds unit tests that capture the currnet expected behavior.