Discrete Baker's Map Introduction

The Baker's map is an important dynamical system that exhibits chaotic behavior.
It is a function from the unit square to itself defined intuitively as follows.


Cut the square vertically in half, resulting in two rectangles of size 0.5&times;1.
Stack the right half on top of the left, resulting in one rectangle of size 0.5&times;2
Compress the rectangle back into a 1&times;1 square.


In this challenge, you'll implement a discrete version of this transformation.

Input and Output

Your input is a 2D array of printable ASCII characters and whitespace of size 2m&times;2n for some m, n &gt; 0.
Your output is a similar array obtained as follows, using the 6&times;4 array

ABCDEF
GHIJKL
MNOPQR
STUVWX


as an example.
First, stack the right half of the array on top of the left half:

DEF
JKL
PQR
VWX
ABC
GHI
MNO
STU


Then, split the columns into pairs of characters, and independently turn each pair 90 degrees clockwise, "compressing" the tall rectangle back to the original shape:

JDKELF
VPWQXR
GAHBIC
SMTNUO


This is the correct output for the above array.

Rules

The input and output formats are flexible.
You can use newline-delimited strings, lists of strings, or 2D arrays of characters.
However, the input and output must have the exact same format: you must be able to iterate your submission an arbitrary number of times on any valid input.

You can write either a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.

Test Cases

Input:
12
34

Output:
42
31

Input:
Hell
!  o
d  -
lroW

Output:
 lol
o W-
!H e
ldr 

Input:
ABCDEF
GHIJKL
MNOPQR
STUVWX

Output:
JDKELF
VPWQXR
GAHBIC
SMTNUO

Input:
*___  ___  o
o|__) |__) *
*|    |    o
o __   __  *
*|    | _  o
o|__  |__| *

Output:
|_____)   *o
 |_ _     *o
||_ __|   *o
o*|_____)   
o* |_ _     
o*||_ _
Pyth, 25 19 18 bytes

msC_dcs_Cmck/lk2Q2


Online demonstration. It uses an 2D-array of chars. 

Array of strings is one char longer (19 bytes). Online demonstration

Explanation:

         m      Q    map each string k in input:
            /lk2        calculate half the line-length: len(k)/2
          ck/lk2        chop k into pieces of length len(k)/2
                        results in two pieces
        C            zip the resulting list
                     results in a tuple ([first half of strings], [second half of strings])
       _             invert the order ([second half of strings], [first half of strings])
      s              sum (combine the two lists to a big one
     c           2   chop them into tuples
m                          for each tuple of strings: 
 sC_d                        invert, zip, and sum


The last part is a bit confusing at first. Let's assume we have the tuple ['DEF', 'JKL'] (I use the example from the OP). 

    d  (('D', 'E', 'F'), ('J', 'K', 'L'))   just the pair of strings
   _d  (('J', 'K', 'L'), ('D', 'E', 'F'))   invert the order
  C_d  [('J', 'D'), ('K', 'E'), ('L', 'F')] zipped
 sC_d  ('J', 'D', 'K', 'E', 'L', 'F')       sum (combine tuples)