Length of the Longest Descent
JavaScript (ES7), &nbsp;106 103 102&nbsp; 98 bytes



f=(m,n=b=-1,x,y,p)=&gt;m.map((r,Y)=&gt;r.map((v,X)=&gt;(x-X)**2+(y-Y)**2-1|v/p?b=n&lt;b?b:n:f(m,n+1,X,Y,v)))|b


Try it online!

Commented

f = (                        // f = recursive function taking:
  m,                         //   m[]  = input matrix
  n = b = -1,                //   n    = length of the current path; b = best length so far
  x, y,                      //   x, y = coordinates of the previous cell
  p                          //   p    = value of the previous cell
) =&gt;                         //
  m.map((r, Y) =&gt;            // for each row r[] at position Y in m[]:
    r.map((v, X) =&gt;          //   for each value v at position X in r[]:
      (x - X) ** 2 +         //     compute the squared Euclidean distance
      (y - Y) ** 2           //     between (x, y) and (X, Y)
      - 1                    //     if A) the above result is not equal to 1
      | v / p ?              //     or B) v is greater than or equal to p:
        b = n &lt; b ? b : n    //       end of path: update b to n if n &gt;= b
      :                      //     else:
        f(m, n + 1, X, Y, v) //       do a recursive call
    )                        //   end of inner map()
  ) | b                      // end of outer map(); return b


How?

During the first iteration, \$x\$, \$y\$ and \$p\$ are all undefined and both tests (A and B in the comments) evaluate to NaN, which triggers the recursive call. Therefore, all cells are considered as a possible starting point of the path.