The Koszul Sign Rule
COW, 363 285 bytes
moOoommoOmoOmoOoomMOOmoOmOoMOOMOomOoMoOmoOMMMMOOMMMMOomOoMOomoOmoOMoOmOoMMMOOOmooMMMmoomoOMMMOOOmOoMMMmOoMOOmOoMMMmoOmoOmoOMMMMOOMOomoOMMMMOOMMMMOoMOoMMMOOOmooMMMMoOmOomoomOomOoOOOmoomOomOoMOOMOomoOMoOmOoMMMMOOMMMMOomoOMOomOomOoMoOmoOMMMOOOmooMMMmoomOoMMMOOOmoOMMMmoOmoOmoOmoomoOmoOOOM

Try it online!
A major change! (It's faster but still test cases exceed the 60 seconds timeout on TIO)
Now I like it better, it's cleaner, symmetric and I've brute forced the memory cells disposition for least number of movements.
The idea is to directly operate in terms of parity. Information in both LSB will be used in each iteration and then a and b will be halved, until b=0.

Every a%2 is calculated (during repeated subtraction) alternating +1 and -1 in one memory cell, so that their partial sum p is available.
When a '1' is found in b, the parity (the answer) is toggled p many times.

Detailed Explanation:
moo ]    mOo &lt;    MOo -    OOO *    OOM i
MOO [    moO &gt;    MoO +    MMM =    oom o


[0]: a/2     [1]: a     [2]: Sum(a%2)     [3]: b%2     [4]: b     [5]: b/2     [6]: parity


&gt;i&gt;&gt;&gt;i                        ;  Read a in [1] and b in [5]
[                             ;  Loop while [5] is non-zero
    &gt;&lt;                        ;     Just 2 instructions for free cause COW doesn't handle consecutive parethesis :D
    [                         ;     Loop while [5] is non-zero
        -&lt;+&gt;=[=-&lt;-&gt;&gt;+&lt;=*]=    ;         SECTION B
    ]                         ;     [5] is 0, [3] is b%2, [5] is b/2
    &gt;=*&lt;=                     ;     Copy [5] in [4], delete [5]
    &lt;                         ;     Point to [3]
    [                         ;     Loop if [3] is non-zero. '1' it's been found in b, parity gets updated
        &lt;=&gt;&gt;&gt;=                ;         Copy [2] in [5]
        [                     ;         Loop while [5] is non zero
            -                 ;             Decrement [5]
            &gt;=[=--=*]=+&lt;      ;             TOGGLE [6]
        ]                     ;  
        &lt;&lt;*                   ;         Delete [3] (to exit the loop)
    ]                         ;     
    &lt;&lt;                        ;     Point to [1]
    [                         ;     Loop while [1] is non-zero
        -&gt;+&lt;=[=-&gt;-&lt;&lt;+&gt;=*]=    ;         SECTION A
    ]                         ;     [1] is 0, a%2 is added in [2], [0] is a/2
    &lt;=*&gt;=                     ;     Copy [0] in [1], delete [0]
    &gt;&gt;&gt;                       ;     Point to [5]
]                             ;     a's and b's LSB have been treated. Now a=a/2 and b=b/2
&gt;&gt;o                           ;  Print [6]

SECTION A ≈ SECTION B is repeated subtraction that divide \$n\$ (a or b, resp.) by \$2\$.
This can't be done in one single step (i.e. --), because \$0\$ can't be surpassed in order to stop (so it'd be -[- =*]=). These sections contextually produce \$n\bmod 2\$ (LSB).
TOGGLE is a toggling method:
When target is 0 it fails the condition and simply +1 is done.
When target is 1 it passes the condition and it's set to -1 so that +1 on exit makes it 0.
Copy, delete, and paste in the same memory cell is a tecnique to treat a while loop like an if loop, also the seemgly useless copy-paste at the beginning of these (=[=) serves to balance the ending one (=*]=) in case if condition fails.