Solution Haskell

solution.hs

import Data.List
import Data.Function
import Control.Monad
import Text.Printf

data Tree a = 
    Leaf | Unary a | Node (Tree a) a (Tree a)
    deriving (Eq, Show)

data From = F | B deriving (Eq, Show)

excerciseTree :: Tree Int    
excerciseTree = Node (Node (Node Leaf 9 (Unary 4)) 5 Leaf) 2 (Node (Node (Unary 11) 6 (Unary 5)) 7 (Unary 2))

collectLayers :: Int -> Tree Int -> [(Int, Int)]
collectLayers n Leaf = []
collectLayers n (Unary x) = [(n, x)]
collectLayers n (Node l x r) = [(n, x)] : collectLayers (n+1) l ++ collectLayers (n+1) r

prepareToPrint :: [(Int, Int)] -> [[(Int, Int)]]
prepareToPrint = reorder F . groupBy groupingFoo . sortBy sortingFoo
    where 
        sortingFoo = compare `on` fst
        groupingFoo = (==) `on` fst
        reorder _ []  = []
        reorder F (x:xs) = reverse x : reorder B xs
        reorder B xs     = last xs : reorder F (init xs)

prepSpiral :: [[(Int, Int)]] -> [Int]
prepSpiral = fmap snd . join

printSpiral :: IO ()
printSpiral = mapM_ (printf "%d ") $ 
    prepSpiral . prepareToPrint $ collectLayers 0 excerciseTree

Ohayo!

3. My guess is that as the number of elements increases, the more in favor of the single-IO-version. About the $ after mapM_... Yeaaaah it
   could be a . but that would feel off... You've noticed, my intent with that was to separate IO from processing visually.

4. OwO spooked

For it to reach 37/37 it would have to be entirely type-level. (one day I will wield that power.... )

Welp, that was fun
https://gist.github.com/Antystenes/0a013dd8863675adf0feed0940d07e4d