Is this platform game level winnable? Given a level from a simple platform game, your task is to make a program or function to determine if a level is winnable. Platform game levels are 4 characters tall and any number of characters wide. There is exactly one platform for each horizontal space in a level:

           =======    =     
==    =           =         
   ===                 =====
  =    ====        ===      


The game consists of jumps. Jumps start from the space above the platform which is being jumped from, and end in the space above the platform which is being jumped to (these can be above the 4 platform height levels). To complete a jump, it must be possible to move from the start point to the end point in four or less (including the start/end points) up, down, left, and right moves which do not pass through a platform. Here are some examples (marked with A for start platform and B for end platform):

 &gt;&gt;&gt;
 ^ B
=A
  =


 &gt;&gt;&gt;&gt;
=A  B=


&gt;&gt;
^B
A


Horizontal moves along a platform are just jumps which only move in one direction:

  &gt;&gt;
==AB===


The player would start on the leftmost platform, and wins by standing on the rightmost one (marked with vs):

v  === v
===   ==


Test cases

Winnable:


 ===      ==
=    =====  
    =       


    ==      

=         ==
 ===  ====  


   ==== =   
===         
       =    
         ===


  ==  ==  = 

=           
 =  ==  == =


Unwinnable:

      ======


======      


 =======   =
=         =
         =
        =


           =
   =        
=     =     
 == == ==== 


Rules

Your program should output one distinct value if a level is winnable, and a different one if it isn't. It can take input in any reasonable form, such as an ASCII art with any two distinct characters, a matrix, or a 2d array.

Code golf, so shortest answer per language wins.
Jelly, 23 22 bytes

ŒṪạþ`§&lt;4NA1¦A»/T$¦ÐLṪṀ


Try it online!

New version, which now efficiently handles moves backwards. Takes input as a boolean matrix (row major). Returns 1 for winnable and 0 for not. 

Thanks to @AZTECCO for first suggesting using the indices of platforms, and @tsh for a test case that made me rethink my approach. 

Explanation

ŒṪ                     | Multidimensional truthy indices of each
  ạþ`                  | Outer table using absolute difference and with the same argument on both sides:
     §                 | Sum innermost lists
      &lt;4               | - Less than 4
        N              | Negate
         A1¦           | Absolute top row
                  ÐL   | Apply the following until no changes:
            A   $¦     | Absolute the rows indicated by the following:
             »/        | - Max of each column
               T       | - Truthy indices (i.e. where there’s a 1 in the column)
                    Ṫ  | Finally take the last row
                     Ṁ | Max


Step b step

(each matrix shown collapsed as a grid, with - = -1):

1. Input

0010
0001
1000
0010
0001
1000


2.ŒṪ

Multidimensional indices.

[[1, 3], [2, 4], [3, 1], [4, 3], [5, 4], [6, 1]]


3. ạþ`§&lt;4N

Convert to initial outer table with -1 for possible moves between columns and 0 where no move possible.

--0-00
--0--0
00--0-
-----0
0-0--0
00-00-


4. A1¦A»/T$¦ÐL

Absolute first row, then iteratively take each column with at least one 1 in it, and absolute the rows at those indices; results after each iteration shown.

Absolute row 1 -&gt;

110100
--0--0
00--0-
-----0
0-0--0
00-00-

-&gt; Absolute rows 1, 2, 4 -&gt;

110100
110110
00--0-
111110
0-0--0
00-00-

-&gt; Absolute rows 1, 2, 3, 4, 5 -&gt;

110100
110110
001101
111110
010110
00-00-

-&gt; Absolute rows 1, 2, 3, 4, 5, 6 -&gt;

110100
110110
001101
111110
010110
001001


5. ṪṀ

Finally, take the max of the last row

1


My previous 61 byte version has explanation in the edit history; thanks to @JonathanAllan for golfing 3 bytes off that one!