WIP: support unwrapping

[piever]

This is an attempt at addressing #13. It is still WIP (I've only done the case with known schema, haven't added tests and have probably forgotten to added the unwrap keyword in a few places) and lacks tests but I hope is good enough to give an idea. It works as follows:

the user passes a unwrap optional argument (defaults to t -> false) that specifies what types should be unwrapped. So the default behavior is unchanged:

julia> x = [(a=(b=1,), c=2)]
1-element Array{NamedTuple{(:a, :c),Tuple{NamedTuple{(:b,),Tuple{Int64}},Int64}},1}:
 (a = (b = 1,), c = 2)

julia> Tables.columns(x)
(a = NamedTuple{(:b,),Tuple{Int64}}[(b = 1,)], c = [2])

julia> unwrap(x) = false
unwrap (generic function with 1 method)

julia> unwrap(::Type{<:NamedTuple}) = true
unwrap (generic function with 2 methods)

julia> Tables.columns(x, unwrap=unwrap)
(a = (b = [1],), c = [2])

From experimentation in StructArrays the compiler is quite good here so it figures out the value of unwrap(T) in advance (at least in general I couldn't find traces of unwrap in @code_llvm and results were inferred correctly).

In #13 I was wrong: there's actually no need to add extra setindex! or push! method provided one is a bit careful in the definition of add!

[piever]

mhm, actually if this is supposed to be overloaded (say to get a DataValueArray or things like that), I should add an extra step in between and not touch this one. So allocatecolumns should call some _allocatecolumn that decides whether calling allocatecolumn or to call back allocatecolumns.

[piever]

I got stuck in the implementation of the type unstable case (in the IndexedTables scenario I think I understand how to do it in full generality but here it doesn't play particularly nicely with the updated trick. I was wondering whether this is the wrong approach (as the code in Tables is quite nice and I woulnd't want to mess it up for this one usecase). Still, I hope this WIP PR is enough to give an idea of the strategy I had in mind.

I'm curious whether this is best done at the level of the element being iterated. For example I could define a:

struct Unwrapped{F<: Function, T}
   unwrap::F
   itr::T
end

whose propertynames are the unwrapped propertynames of el (with some unique names). For example in the case of (a=(b=1, c=2), d=3) the unwrapped propertynames would be (b, c, d) (some care is needed to avoid repetition) and everything would proceed as usual, but somehow the information of the row type is kept so that one can remap the collected columns in the end to turn (b=vb, c=vc, d = vd) into (a=(b=vb, c=vc), d=vd). Does that make sense?