text:
Flatten the CUBE
Do you ever look at 3D shapes and think that we have 2 many dimensions. So let's make 3D into 1D! (See what I did there?)
Task
Given a 2D representation of a cube (layout below), flatten it into a single string, based on pointers.
The CUBE
This is the layout of the cube filled with no-ops (,) and pointers at the corners (<>v^/). The Navigation Pointer (NP) begins the program where shown.
         | NP begins here, moving right.
         V
         >,,,,,,,,,,,,,,,,,,v
        ,                  ,,
       ,                  , ,
      ,                  ,  ,
     ,                  ,   ,
    ,                  ,    ,
   ,                  ,     ,
  ,                  ,      ,
 ,                  ,       ,
/,,,,,,,,,,,,,,,,,,/        /
,                  ,       ,
,                  ,      ,
,                  ,     ,
,                  ,    ,
,                  ,   ,
,                  ,  ,
,                  , ,
,                  ,,
^,,,,,,,,,,,,,,,,,,<

The NP continues moving right from the start until it meets a corner. Each corner has a default direction that, unless overridden at the corner by a pointer, will point the NP in a new direction. They are shown on the above diagram. The pointers in the program are v^<>/ (the / points it either down or up, due to the layout there will never be any confusion between the two)
The NP stops moving when it reaches the ¶ symbol (Yes I know this is a multi-byte character, deal with it). Each character it goes over is added to the final output string except for the pointers, the no-op (,) and the ¶ symbol.
Input
Input will be a multi-line string that matches the layout of the CUBE with the non-whitespace characters replaced with any character in the range 0x21 to 0x7E and at least one instance of the EOF.
You may take input as:

A multiline string
A list of strings where each line is a new element in the list
A 2D list of strings where each line is broken down into a list

Output
The cube, flattened down into a single line string.
Conditional Pointer
The NP has a boolean value that is used for something called a "conditional" pointer that begins at true.
The "conditional" pointer (?) is a pointer which will alternate the NP value between true and false every time it is used. Conditional pointers only take effects when used on the corners where 3 tracks (3-point corner) meet. If the value is true when the NP reaches the conditional pointer, the NP moves to the default direction in the CUBE image and, after being directed, the NP value is toggled. Therefore, if it is on false, the NP follows the non-default direction.
There will never be an instance where the NP goes towards a conditional and the default direction is the direction it just came from. Imagine that this is the left corner of the front face and the NP value is currently true:
      NP direction
      /
     ,
    ,
,,,?
   ,
   ,

This will never happen as the default direction will mirror it back to how it was.
If the conditional pointer is on an 3-point corner:

It isn't added to the final string
The NP value is toggled between true and false after the NP has been directed.
If the NP value is true, the NP is redirected to the default direction. Otherwise, it is redirected to the non-default direction.

If it is on a track or a 2-point corner:

It is added to the final string
the value is toggled
The IP isn't directed

Something to watch out for
If a pointer is on a track and it doesn't point into spaces, the NP is directed into the new track, adds the next character to the final string and rotates the NP by 90 degrees to the right.
 abcd
   >e
  g f
 /
NP direction

would flatten to
(...) gef (...)

NOT
(...) g>def (...)

A / pointer doesn't redirect the NP in this instance as it may redirect into a space so
     f
     e
> ab/d

would become ab/def
Rules

The width, height and depth of the cube may change
The height and depth of the cube will always be the same and will be half the width, so the width will always be even.
The width will be between (inclusive) 6 and 60.
There will always be an EOF (¶) that can be reached by the NP. E.g there will never be something like this in the cube: <¶> as the NP would never be able to reach the cube.
As a space cannot be inserted into the cube's tracks, the final string shouldn't ever have a space in it.
If a pointer is placed in one of the tracks (not on a corner) and it would direct the NP into spaces, the NP stays constant and the character is added to the final string.
However, if the pointer keeps it on the track, the NP is directed and the pointer character isn't added
As no-ops (,) aren't added to the final string, the final string shouldn't contain any , in it.
You can assume that the input will be correct.
This is a code-golf so shortest code in bytes wins!

Examples
Input
Output
-----
Input
Output

  abcdef
 ¶    ,g
q,,,,, h
p    ,i
onmlkj

abcdefghijklmnopq

-----

         >,,,,,,,,,,,,,,,,,,v
        ¶                  ,,
       ,                  , ,
      ,                  ,  ,
     ,                  ,   ,
    ,                  ,    ,
   ,                  ,     ,
  ,                  ,      ,
 ,                  ,       ,
/,,,,,,,,,,,,,,,,,,/        /
,                  ,       ,
,                  ,      ,
,                  ,     ,
,                  ,    ,
,                  ,   ,
,                  ,  ,
,                  , ,
,                  ,,
^,,,,,,,,,,,,,,,,,,<

nothing

-----

                   Mr/~gm,Vc!r,0cbmPC@Zg9jb)7=m^ppwN*Nuk){r
                  c                                      ¶Z
                 J                                      ; #
                e                                      j  8
               ]                                      b   "
              #                                      `    4
             h                                      $     -
            p                                      n      2
           L                                      S       P
          B                                      ;        R
         @                                      J         D
        E                                      N          <
       O                                      \           p
      B                                      y            =
     |                                      9             ;
    T                                      x              [
   6                                      o               k
  !                                      L                =
 E                                      K                 ~
>mjmz6,?A*Q)^.a:IpGP"^bK}DSXL)2F!BV|"m6/                  T
a                                      A                 6
5                                      =                p
1                                      i               R
4                                      /              ?
-                                      Z             (
1                                      "            `
'                                      0           {
N                                      p          M
O                                      *         K
Z                                      J        $
"                                      (       d
4                                      +      o
f                                      U     g
i                                      v    b
U                                      ~   L
U                                      M  h
g                                      ^ D
2                                      (g
5]u*n<Ldn</9/XQyC444Va\m}W3Rf,rp"a@5cZB0

(Newlines added for readability)
Mr/~gmVc!r0cbmPC@Zg9jb)7=m^ppwN*Nuk){rZ#8"4-2PRD<p=;[k=~T
6pR?(`{MK$dogbLhDg0BZc5@a"prfR3W}m\aV444CyQX/9/ndLn*u]52g
UUif4"ZON'1-415amjmz6?A*Q)^.a:IpGP"^bK}DSXL)2F!BV|"m6KLox9
y\NJ;Sn$`bj;

-----

       NEWYORKCITYBABY!
      ¶              ,,
     ,              , ,
    ,              ,  ,
   ,              ,   ,
  ,              ,    ,
 ,              ,     ,
,,,,,,,,,,,,,,,,      ,
,              ,     ,
,              ,    ,
,              ,   ,
,              ,  ,
,              , ,
,              ,,
,,,,,,,,,,,,,,,,

NEWYORKCITYBABY!

-----

                          /{Y!_(=-)s<e!D^<+<+1o30d>QOx9kfu?3X2I:8],t>Ye~,Y9/6;u@
                         ]                                                    >Y
                        !                                                    1 )
                       c                                                    7  8
                      ^                                                    K   &
                     f                                                    K    9
                    M                                                    }     O
                   s                                                    _      ?
                  h                                                    N       e
                 ?                                                    u        ,
                g                                                    =         s
               >                                                    Q          M
              a                                                    0           9
             b                                                    c            (
            h                                                    {             c
           [                                                    m              *
          I                                                    R               %
         K                                                    E                >
        u                                                    5                 n
       W                                                    f                  ]
      }                                                    |                   y
     F                                                    E                    q
    )                                                    <                     ;
   X                                                    L                      S
  F                                                    M                       |
 u                                                    *                        Z
>XZpJ=L`+8ONRk?T7$qVr6-U^f14{>>ABEEP`Mjx&T[/&o*F=*qq{/                         e
¶                                                    <                        ^
+                                                    P                       C
.                                                    x                      m
;                                                    ^                     >
y                                                    4                    b
5                                                    v                   `
Q                                                    B                  c
2                                                    e                 r
a                                                    x                I
3                                                    1               Y
Q                                                    v              `
w                                                    ;             o
*                                                    S            h
E                                                    b           S
r                                                    6          P
M                                                    `         l
%                                                    M        A
-                                                    `       "
j                                                    \      s
}                                                    ~     J
$                                                    h    c
%                                                    p   O
I                                                    Z  Z
]                                                    N E
`                                                    3<
x^}}SI"-a3[%7U5EV}"UM?Aov|E_yjrMt<HAQ@}QAABO&y//R0$\2p

(Newlines added for readability)
]!c^fMsh?g>abh[IKuW}F)XFuXZpJ=L`+8ONRk?T7$qVr6-U^f14{ABEE
P`Mjx&T[/&o*F=*qq{*ML<E|f5ERm{c0Q=uN_}KK71Y)8&9O?esM9(c*%
>n]yq;S|Ze^Cm>b`crIY`ohSPlA"sJcOZE3NZph~\`M`6bS;;Sb6`M`\~
hpZN3p2\$0R//y&OBAAQ}@QAHtMrjy_E|voA?MU"}VE5U7%[3a-"IS}}^
x`]I%$}j-%MrE*wQ3a2Q5y;.+

-----

   %:biv+|?
  ¶      \+
 T      c ,
?{yX<//v  "
i      [ @
Q      Tj
U8sUNl.?

%:biv+|+"@jT[[T.lNUs8UQi{yXXy{T

-----

     FCf2hoYA)&*j
    F          ¶#
   3          p (
  &          ~  w
 ;          *   t
39Hq{F'MmmO/    9
5          \   D
-          |  }
8          c l
a          25
GKa"<0/7MG[?

FCf2hoYA)&*j#(wt9D}l5[GM7/0"aKGa8-53;&3FFCf2hoYA)&*j#(wt9D}l52c|\*~p

-----

           #S^[WNk3;9v;e2\h!@CI#Il?
          G                      g`
         $                      2 \
        V                      9  S
       m                      Y   b
      6                      )    *
     U                      '     V
    [                      g      V
   I                      8       X
  <                      T        U
 K                      ¶         C
?ozMt+xxxxutvQgkx&D9I/<v          '
w                      K         p
V                      y        h
(                      R       y
e                      P      i
]                      !     x
Z                      /    s
y                      w   '
#                      X  4
c                      ~ W
Z                      E,
~IdXPYS.Lc49lC~vjULUBv.?

(Newlines added for readability)
#S^[WNk3;9v;e2\h!@CI#Il`\Sb*VVXUC'phyixs'4WE~Xw/!PRyKKyRP!/wX~E
.vBULUjv~Cl94cL.SYPXdI~Zc#yZ]e(VwozMt+xxxxutvQgkx&D9I//I9D&xkgQ
vtuxxxx+tMzoK<I[U6mV$G#S^[WNk3;9v;e2\h!@CI#Ilg29Y)'g8T

No problem :) Really nice challenge btw! :)

@HyperNeutrino I kinda feel guilty now that the bounty has started. This was a project that I was working on but gave up and decided to post. So I can just polish off my old solution and post it for the bounty! I'll only do that  if there are no answer by the end of the week, though

@RandomUser go ahead and post an answer now, people will be more inclined to answer when they have something to beat. And don't feed guilty, it's the equivalent of 5 answer upvotes.

@programmer5000 It's not finished and no where near golfed but I should get it done in a few days

@RandomUser derp

Vim, 971 bytes
Go<C-v><C-v><C-v>
elsei'<C-v><C-v><C-v><C-r>t'==<Esc>^"zC<C-v><C-v><C-v>
let@b=<Esc>^"fC<C-v><C-v><C-v>
let@O=<Esc>^"xC:if'<C-v><C-v><C-v><C-r>0'==' '<Esc>^"yC<C-v><C-v><C-v>
norm <Esc>^"wC<C-v><C-v><C-v>
let@m='<Esc>^"vC'<C-v><C-v><C-r>f0<C-v><C-v><C-v>
el<C-v><C-v><C-v>
if'<C-v><C-v><C-v><C-r>m'=='<Esc>^"aCyl:if'<C-v><C-v><C-v><C-r>0'!=' '<C-v><C-v><C-v>
let@T=<Esc>^"hC457||<C-v><C-v><C-v><C-r>t==147<C-v><C-r>vlk'<Esc>^"iC@n:if<C-v><C-v><C-v><C-r>t==<Esc>^"jC@nlylh<C-r>y<C-r>x'>'<C-r>w@m<C-r>z234568<C-r>wl<C-r>vj'<C-v>
el<C-r>wl<C-r>vl'<C-v>
en<C-v>
<Esc>^"rC@nhyll<C-r>y<C-r>x'<'<C-r>w@m<C-r>z1248<C-r>wh<C-r>vk'<C-v>
el<C-r>wh<C-r>vh'<C-v>
en<C-v>
<Esc>^"lC@nkylj<C-r>y<C-r>x'^'<C-r>w@m<C-r>z234568<C-r>wk<C-r>vl'<C-v>
el<C-r>wk<C-r>vk'<C-v>
en<C-v>
<Esc>^"uC@njylk<C-r>y<C-r>x'v'<C-r>w@m<C-v>
el<C-r>wj<C-r>vj'<C-v>
en<C-v>
<Esc>^"dC<C-r>j<C-r>i<C-r>z38<C-r>vhj'<C-v>
el<C-r>x'/'<C-v>
en<C-v>
<Esc>^"sC<C-r>j178<C-v>
if<C-v><C-r>b<C-r>vj<C-r>al'<C-r>vhj'<C-v>
el<C-r>vh'<C-v>
en<C-r>f1<C-v>
en<C-r>z147<C-v>
if<C-v><C-r>b<C-r>vlk<C-r>al'<C-r>vj'<C-v>
el<C-r>vh'<C-v>
en<C-r>f1<C-v>
en<C-r>z134<C-v>
if<C-v><C-r>b<C-r>vh<C-r>aj'<C-r>vlk'<C-v>
el<C-r>vk'<C-v>
en<C-r>f1<C-v>
en<C-r>z457<C-v>
if<C-v><C-r>b<C-r>vlk<C-r>ah'<C-r>vj'<C-v>
el<C-r>vl'<C-v>
en<C-r>f1<C-v>
en<C-v>
el<C-r>x'?'<C-r>f(<C-v><C-r>b+1)%2<C-v>
en<C-v>
<Esc>^"qC"tyl:if'<C-v><C-r>t'=='>'<C-r>w@r<C-r>z'<'<C-r>w@l<C-r>z'v'<C-r>w@d<C-r>z'^'<C-r>w@u<C-r>z'/'<C-r>w@s@e<C-r>z'?'<C-r>w@q@e<C-r>z'█'<C-r>wHdG"op<C-v>
k<C-r>z','<C-r>w@e<C-v>
el<C-r>w"Oyl@e<C-v>
en<C-v>
@c<Esc>^"cCma@myl<C-r>y<C-r>w`a@g<C-r>w@m<C-v>
en<C-v>
<Esc>^"eC<C-r>j58<C-r>vl'<C-r>z178<C-r>vj'<C-r>z38<C-r>vhj'<C-r>z134<C-r>vh'<C-r>z35<C-r>vk'<C-r>z<C-r>i<C-v>
en<C-v>
<Esc>^"gC:let@t=''<C-v>
h<C-r>h1<C-v>
en<C-v>
<C-v><Esc>k<C-r>h2<C-v>
en<C-v>
l<C-r>h3<C-v>
en<C-v>
l<C-r>h4<C-v>
en<C-v>
j<C-r>h5<C-v>
en<C-v>
j<C-r>h6<C-v>
en<C-v>
h<C-r>h7<C-v>
en<C-v>
h<C-r>h8<C-v>
en<C-v>
<C-v><Esc>kl<Esc>^"nC1l<Esc>"mx"bxgg
@c

Try it online!
That's a chonker of a Vim program right there. The inputted cube requires a padding of spaces around the sides. Additionally, I used █ instead of ¶ as the stopping point, but that is only because ¶ has a special meaning in V. You can replace the █ with ¶ and it will run just fine in Vim.


text:
Fix my notation for lists of matrices, part 1
Sometimes, I have lists of constant matrices in my code:
[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

That's a terrible use of screen real estate. I'd much rather write them next to each other:
[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

You'll find that this is still a syntactically valid nested list, it's just no longer rectangular and it has a very different structure (in particular, it gets deeper every time I add a matrix larger than 1x1). However, it's still possible to reconstruct the initial list of matrices from this new list.
So that I can use this syntax in the future, I need you to write some code which converts arrays that were written in a horizontal arrangement to the list of matrices they represent.
To make sure that answers don't perform 2D pattern matching on the layout in the source code, the input will be given either as just the array object, or if you take a string representation, then it will not contain any whitespace indicating how the literal was written in the code. So you'd get some input like this:
[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

And the output should be the following array or its string representation (again, no further layout is needed):
[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

This is the first and easier part of a two-part challenge. In this one, you may assume that all matrices are square and have the same dimensions and that they are properly aligned next to each other. In the second part we'll relax these assumptions.
Rules
The input will be a nested list or its canonical string representation (in your language of choice), and you should output the result in the same format. The result will always contain at least one matrix, and the matrices can be as small as 1x1. The matrices will only contain (signed) integers with absolute value less than 128.
You may write a program or a function and use any of the standard methods of receiving input and providing output.
You may use any programming language, but note that these loopholes are forbidden by default.
This is code-golf, so the shortest valid answer – measured in bytes – wins.
Test Cases
Each test case has a) the list matrices laid out nicely next to each other as they would be in the code (this is not your input), b) the unformatted list without the extraneous whitespace (this is your input), c) the expected output.
Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

I think I might know what inspired this challenge...

Is [([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])] valid output for the third testcase? It is mixed list and tuple.

@ovs No, sorry. Since input and output format should match, the corresponding input would be [([1,0], ([1, 0}, ... and that would give you additional information.

@Neil what inspired this challenge?

@RandomUser The desire to golf all the things. Least amount of screen real estate wins!

@RandomUser this did.

Jelly, 20 15 13 11 bytes
Fðs⁹œsZµḢḢL

Try it online!
Background
Like most things, this challenge is rather simple once you've figured out what you have to do. And I eventually did, after three deletions and one rollback...
First, we must figure out the dimensions of the matrices. That's easier done than said: the first element of the first element is the first row of the first output matrix, so its length is equal to the number of columns of the square output matrices.
For example, if the input is
[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

the first element of the first element is [1, 0, 0], whose length is ℓ = 3.
If we flatten the input and split it into chunks of that length, we get all rows of the output matrices, albeit in the wrong order. For our example input, this gives
[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

To obtain the final output, we must first split the row array into ℓ chunks of equal length. For our example input, this gives
[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

Each column is now one of the output matrices, so transposing the resulting matrix of arrays is all that's left to do. For our example input, that gives
[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

as desired.
How it works
Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)

F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.

       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.

 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Pyth, 12 bytes
CcJlhhQc.nQJ

This is a port of my Jelly answer.
Try it online!
How it works
Pyth parses the program as follows (pseudo-code).
C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q is a variable that holds the input. J is an undefined variable.
First J = l(h(h(Q))) stores the length of the head (first element) of the head of Q in J.
Then, .n(Q) flattens Q, and c(..., J) splits the result into pieces of length J.
Afterwards, c(J, ...) splits the result in J pieces.
Finally, C(...) transposes the result.

sancta mater dei

Pyth, 29 bytes
.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

Test suite.
How it works
.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

Algorithm
Let's work on the input [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].
We will be using pure string operations here.
Firstly, we split the input at the commas which are not part of the deepest list (this is done by splitting at the regex \B,):
[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

Then, we find the index of the first substring which does not start with [[ (this is done by checking whether the character at index 1 is [). In this case, it is 4, because the substring at index 4 is [0,1]] which does not start with [[.
Then, we group the substrings in groups of 4, and then transpose:
[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

And then we join them with commas:
[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

You were just massively outgolfed by Dennis.

JavaScript (ES6), 132 130 bytes
f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

There are four cases:

A 1×n array, which is just returned (this is the first test, but inverted)
An m×n array which hasn't been flattened yet, which we recursively flatten by one step, counting n at the same time.
An m×n array which has been flattened, where we filter out every nth element.
An m×1 array, which is just returned

05AB1E, 11 bytes
A port of Dennis' answer. Code:
¬¬g¹˜sô¬gäø

Uses the CP-1252 encoding. Try it online!

Mathematica, 104 bytes
l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

Input

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0}}, {1,
     0}}}

output

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1}, {1,
     0}}}

input

{{{1, 0, 0}, {{127, 63,
      31}, {{1, 0,
       0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0,
        0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {0, 0, 0}}}

output

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15,
     0, -15}, {-31, -63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0,
      0, 0}, {0, 0, 0}, {0, 0, 0}}}

{{{0}}}  and  {{{-1}}, {{0}}, {{1}}}   work,too
-11 bytes thanks to Martin Ender

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes