Kinda depends on how I interpret your question.
Vector of nD Arrays is basically a list of pointers to arrays, so iterating through it inherently requires following a pointer. This is different from an (n+1)D Array, which can be stored densely in a single contiguous piece of memory. This has fairly significant performance implications, thus I am happy that Julia makes interacting with them explicitly different.
If you do want the more convenient indexing, you can use tools like RecursiveArrayTools.jl which simplify the indexing for you.
Concerning why cat added a new index at the end instead of at the beginning, it is because I used dims=4. By the way, there is a literal version of cat that is equivalent: [vec_of_arr...;;;;] where the number of semicolons specifies the dimension along which you want to concatenate. Both cat and the literal inherit this style from how array literals work in julia: each semicolon adds a new dimension (at the back of the list of indices).
Lastly, the order of indices, I claim, is consistent with the fact that Julia has Fortran style, not C style matrices. I.e. the first index is the fastest growing one, not the last index. E.g. see this example:
julia> a = [1 3; 2 4] # or maybe a = [1; 2;; 3; 4] to make it more explicit
2×2 Matrix{Int64}:
1 3
2 4
julia> a[1], a[2], a[3], a[4] # single-index lookup gives us the contiguous in-memory array
(1, 2, 3, 4)
julia> a[1,1], a[1,2] # modifying the last index causes discontinuous jumps
(1, 3)
julia> a[1,1], a[2,1] # modifying the first index gives neighbors
(1, 2)
Thus, the first index should refer to contiguous neighbors-in-memory, while the last index should refer to big jumps in memory, which hopefully makes what you are observing make sense.