added the extra compact (not obfuscation minify, just func-style) solution with explanetions of my hacks ;-)

Under Technical Details:

• Each test case may have 0 or more possible solutions

Have to rewrite solver very compact, with bithacks.
And use custome debug with qute console log of maze layers:

['', 'E', '', 'E', '', 'E', '', 'EES', 'S', 'E', 'ESSS', 'S']

 [0] 0 1 2 3 4 5 6 7
 0 | +@+ + + + + . . 0
 1 | ^ . ^ ^ > + < . 1
 2 | + + + < < ^ . . 2
 3 | ^ + + + . . . . 3
 4 | . + ^ . . . . . 4
 5 | . + + + . . . . 5
 6 | . ^ ^ + < < . .*6
 7 | . . . > ^ . . . 7
    [1] 0 1 2 3 4 5 6 7
    0 | +@< + < + + < . 0
    1 | + . + + + + + . 1
    2 | + v v + + + < . 2
    3 | + < < + < . . . 3
    4 | . ^ + . . . . . 4
    5 | > + + + v < . . 5
    6 | . + + + + + . .*6
    7 | . . > + + < . . 7
        [2] 0 1 2 3 4 5 6 7
        0 | +@+ + + + + + . 0
        1 | + . + + + + + . 1
        2 | ^ + + + + + + < 2
        3 | + + + + + ^ . ^ 3
        4 | . + + . . . . ^ 4
        5 | + + + + + + < ^ 5
        6 | . + + + + + . .*6
        7 | . ^ + + + + . . 7
            [3] 0 1 2 3 4 5 6 7
            0 | +@+ < + < < + . 0
            1 | + . + + + ^ + . 1
            2 | + + + + + + + + 2
            3 | + + + < + + . + 3
            4 | . + + . . . > + 4
            5 | + ^ < < + + + + 5
            6 | . + + ^ + + . ^*6
            7 | . + + + + + . . 7

The 1st example can be solved in differetn way?
That is:

['NNE', 'EES', 'S', 'S']

• or i don't understend some limitations?

The current performance trick is lookup table for all 2**n index of Fibonacci values Array(21) at all.

Then in computation it uses for sum by bits of index some Fibonacci values (avg 9 parts) by simple dot product twice.

This make pretty fast computation in strass loop, with no powers only 4 mul + 2 sum. (avg 32mul +16sum of bigint per request)

The topicaster advice to use powers is not the best!
With lookup table the sums are enough!

It can be speed up more with create lookups for group of bits (pre sumary pairs or quadruples)

why =a ?
just you can?

the most increadible way, witch use only algorithmic dependencies, above langage sugar as RegExp, reduce or some!

Please use spoiler flag next time.