Going one step further, if the argument in the call were x(1:,i2,1:), then with an implicit interface (or the appropriate explicit interface) I think the compiler would be required to do the copy-in/copy-out, and the stride argument would need to be changed (to n1 I think) to account for the contiguous nature of the intermediate array copy. On the other hand, if the dummy argument were an assumed shape 2D array with an explicit interface, then the compiler would not be required to make a temporary copy (although it could if it wanted).
When the actual and dummy array arguments are explicit shape or assumed size, then the actual argument x(1,i2,1) is standard conforming. When the actual array is assumed shape, then x(1,i2,1) is not standard conforming, and compilers will catch the error and likely print an informative error message. The argument x(1:,i2,1) is not standard conforming, but it is likely to work nonetheless, without a compiler warning. The argument x(1,i2,1:) is not standard conforming, and it will almost certainly fail because the compiler will generate an intermediate 1D array of length n3, and then the subroutine will try to references n1*n3 elements in that array. The argument x(1:,i2,1:) is standard conforming, but it would require some of the other arguments in the call to change. All that seems complicated, even for an experienced programmer.