Fix multi-dimensional VectorOfArray broadcast

[jlchan]

Addresses #373

The fix just involves modifying Base.copy for VectorOfArray with multi-dimensional parent arrays. This could replace the old Base.copy implementation, but I left the old implementation there just in case it changes behavior upstream.

[jlchan]

Side note, this entire block can be replaced by the second branch

return VectorOfArray(map(enumerate(Iterators.product(axes(parent)...))) do (i, _)
    copy(unpack_voa(bc, i))
end)

since enumerate(Iterators.product(axes(parent)...))) do (i, _) basically recovers map(1:N) do i for an AbstractVector.

I left the old behavior in since I wasn't sure if it would break something upstream or change performance (and it's easier to read).

[jlchan]

Broadcasting similar here avoids some #undef issues.

[jlchan]

Side note: this implementation could replace these 3 functions

RecursiveArrayTools.jl/src/vector_of_array.jl

Lines 715 to 729 in eacbe3f

	@inline function Base.similar(VA::VectorOfArray, ::Type{T} = eltype(VA)) where {T}
	VectorOfArray([similar(VA[:, i], T) for i in eachindex(VA.u)])
	end
	# for VectorOfArray with multi-dimensional parent arrays of arrays where all elements are the same type
	function Base.similar(vec::VectorOfArray{
	T, N, AT}) where {T, N, AT <: AbstractArray{<:AbstractArray{T}}}
	return VectorOfArray(similar(Base.parent(vec)))
	end
	# special-case when the multi-dimensional parent array is just an AbstractVector (call the old method)
	function Base.similar(vec::VectorOfArray{
	T, N, AT}) where {T, N, AT <: AbstractVector{<:AbstractArray{T}}}
	return Base.similar(vec, eltype(vec))
	end

However, doing so breaks these tests because similar can't be called on <:Real values:

RecursiveArrayTools.jl/test/basic_indexing.jl

Lines 221 to 229 in eacbe3f

	x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
	testva = DiffEqArray(x, x)
	testvb = DiffEqArray(x, x)
	mulX = sqrt.(abs.(testva .* testvb))
	ref = sqrt.(abs.(x .* x))
	@test mulX == ref
	fill!(mulX, 0)
	mulX .= sqrt.(abs.(testva .* testvb))
	@test mulX == ref

These tests don't seem correct to me; the parent array x doesn't have underlying data structure Vector{AbstractArray{T}}, so it shouldn't be a valid edge case. Maybe I'm missing something?

[ChrisRackauckas]

Numbers are also allowed. That's used a lot downstream.

[ChrisRackauckas]

We can special-case that case where the elements are numbers, but we cannot throw it out.

[jlchan]

Applying formatting introduces a bunch of spurious file changes so I'm skipping it for now.

[jlchan]

Thanks for the quick review!