The reason why those two semantics are different, is that methods and functions are not the same thing.
Methods are full-fledges JVM methods, whereas functions are values (i.e. instance of classes like Function1, Function2 and so on).
So
def sum(x: Int)(y: Int)(z: Int) = x + y + z
and
val sum = (x: Int) => (y: Int) => (z: Int) => x + y + z
may seem identical, but the first is an method, while the second is a Function1[Int, Function1[Int, Function1[Int, Int]]]
When you try to use a method where a function value is expected, the compiler automatically converts it to a function (a process called eta-expansion).
However, there are case in which the compiler doesn't eta-expand the methods automatically, such as the cases you exposed, in which you explicitly want to partially apply it.
Using _ triggers the eta-expansion, so a method is converted to a function, and everybody is happy.
According to the scala specification, you could also annotate the expected type, in which case the expansion is performed automatically:
def sum(x: Int)(y: Int)(z: Int) = x + y + z
val sumFunction: Int => Int => Int => Int = sum
which is the same reason why
def sum(x: Int, y: Int) = x + y
List(1,2,3).reduce(sum)
works, i.e. we're passing a method where a function is explicitly required.
Here's a more in-depth discussion of when scala performs an eta-expansion: http://stackoverflow.com/a/2394063/846273
Concerning the choice of which to adopt, I'll point you to this answer, which is very exhaustive.
