JavaScript (ES6), 78 77 76 bytes

m=>(M=g=s=>(v=(m[y]||0)[x])?g(s+=v,y++)|g(s,x++,y--)*x--|M<s?M:M=s:0)(x=y=0)

Try it online!

Commented

m => ( // m = input matrix
 M = // initialize the minimum M to a non-numeric value
 g = s => // g = recursive function taking the current sum s
 (v = (m[y] || 0)[x]) ? // if the current cell v is defined:
 g(s += v, y++) | // do a recursive call at (x, y + 1)
 g(s, x++, y--) * x-- // do a recursive call at (x + 1, y)
 | // if at least one call did not return 0 (which means
 // that we haven't reached the bottom-right corner)
 M < s ? // or M is less than s (false if M is still non-numeric):
 M // return M unchanged
 : // else:
 M = s // update M to s, and return this new value
 : // else (we're outside the bounds of the matrix):
 0 // return 0
)(x = y = 0) // initial call to g with s = x = y = 0

Haskell, 63 57 bytes

f x@((a:_:_):c:d)=a+min(f$c:d)(f$tail<$>x)
f x=sum$id=<<x

Try it online!

f x@((a:_:_):c:d)= -- if it's at least a 2x2 matrix
 a+min -- add the top left element to the minimum of the
 -- path costs of
 f$c:d -- the matrix with the first row dropped and
 f$tail<$>x -- the matrix with the first column dropped
f x= -- else, i.e. a 1xm or nx1 matrix, i.e. a vector
 sum$id=<<x -- return the sum of this vector

MATL, 38 36 30 29 bytes

Thanks to @Giuseppe for pointing out a mistake, now corrected.

lyZyqsG&nghZ^Yc!tsGz=Z)Ys)sX<

Try it online! Or verify all test cases.

Explanation

l % Push 1
y % Input, implicit. Duplicate from below. Pushes the input below
 % the current 1, and a copy of the input on top
Zy % Size of input. Gives [m, n]
qs % Subtract 1 element-wise, sum. Gives m+n-2
G % Push input again
&n % Push size as two separate numbers. Gives m, n
gh % Transform n into 1 and concatenate horizontally. Gives [m, 1]
Z^ % Cartesian power of [m, 1] raised to m+n-2. This produces the
 % Cartesian tuples as row of a matrix. A typical tuple may be
 % [1, m, 1, m, m]. This will define a path along the matrix in
 % linear, column-wise indexing (down, then across). So 1 means
 % move 1 step down, and m means move m steps "down", which is
 % actually 1 step to the right
Yc % Concatenate strcat-like. This prepends the 1 that is at the
 % bottom of the stack to each row
! % Transpose. Each tuple (extended with initial 1) is now a column
!ts % Duplicate, sum of each column
Gz % Number of nonzeros of input. Gives m*n-1
=Z) % Keep only columns that sum m*n. That means that, starting from
Ys % Cumulative sum of each column. This defines the path
) % Index: pick entries specified by the path
s % Sum of each column
X< % Minimum
 % Display, implicit

R, 90 bytes

function(m)l=sum(m

Try it online!

The naive solution: iterate through the array (down the columns), replacing each entry by the sum of itself and the minimum of its above and to-the-left neighbors, if they exist, then return the last entry.

Perl 6, 57 54 bytes

my&f=0

Try it online!

Explanation

my&f= # Function f
 |.flat&& # Return empty slip if matrix is empty
 .[0;0]+ # Value at (0,0) plus
 min # Minimum of
 f(.[1..*]) # Rows 1..*
 f $_>>[1..*] # Columns 1..*
 ( , )||0 # Or 0 if empty

Röda, 100 89 bytes

f Ag=ming#A-1,#A[0]-1

Try it online!

-9 bytes thanks to Cows quack

Python 3, 108 bytes

def f(A,m,n,i=0,j=0):r=i+1<m and f(A,m,n,i+1,j);d=j+1<n and f(A,m,n,i,j+1);return A[i][j]+min(r or d,d or r)

Try it online!

Ungolfed

def f(A, m, n, i=0, j=0):
 right = i + 1 < m and f(A, m, n, i + 1, j)
 down = j + 1 < n and f(A, m, n, i, j + 1)
 return A[i][j] + min(right or down, down or right)

APL (Dyalog Classic), 37 32 bytes

⊃⌽,9e9(⊢⌊⍵+(2⊣⌿⍪)⌊2⊣/,)⍣≡+⍀+⍵

Try it online!

+⍀+ partial sums horizontally and vertically - this provides an initial overestimate for the paths to each square

9e9(...)⍣≡ apply "..." until convergence, at each step passing some very large number (9×10⁹) as left argument

, add 9e9-s to the left of the current estimate

2⊣/ take the first from each pair of consecutive cells, effectively dropping the last column

2⊣⌿⍪ same thing vertically - put 9e9 on top and drop last row

(2⊣⌿⍪) ⌊ 2⊣/, minima

⍵+ add the original matrix

⊢⌊ try to improve the current estimates with that

⊃⌽, bottom-right cell