That's a great way of looking at it. In some sense, partial application is "inverse" of currying, and, as you showed, you can use partial application in a way that looks almost identical to currying on the outside!
Thinking of partial application as Fn -> Fn-1 -- that is, accepting a n-argument function and giving you back an n-1 arity function with one arg pre-applied -- as you suggested, is a great insight, and one that makes the analogy with currying much more clear. Since this accepts a function and gives you back a function, it's just a function itself, which we can call ρ. By iterating this process, we can go from Fn -> Fn-1 -> ... -> F1, and each of these arrows is just ρ. Now, we know that currying takes in a function of n arguments and gives us a function of 1 argument. In other words, currying is a function (let's call it γ) which does Fn -> F1. Since each of the arrows in the partial application sequence is simply ρ which is a function, we can define a composed function which goes from Fn all the way to F1, that is, ρ* : Fn -> F1. Now the question is:
Are these two the same?
That is, is ρ* the same as γ? They have the same signatures Fn -> F1, and they are given the same input function f. But in fact, the output function is quite different in the two cases. Let's call the result of partial application fp and the result of currying fc. In the case of fp, it accepts one argument and gives us the result of the original n-ary function. On the other hand, for fc, it accepts one argument and gives us a function. If we keep iterating this currying process, we get a sequence like this: fc -> f2 -> f3 -> ... -> fn (here the subscript is just an index and doesn't indicate arity as it did earlier with capital F -- and each of these functions is 1-ary!). At this point, calling fn with an argument would produce the final result of the original n-ary function. Here, we have another sequence of functions -- just like we did earlier "on the other end" with partial application, and just as we did there, we can define a composed function fc* here, that is, fc* is a function fc -> fn. This is very handwavy at this point, since we haven't really explained how any of these functions work. But still, we can safely guess that the function fc* is going to be one that accepts N-1 arguments, in order to apply each of the currying steps, and we know that it produces a function that accepts 1 argument, fn. In other words, given only the sequence of curried functions, we can define a new function that accepts n-1 arguments and gives us a function that accepts 1 argument, which, when called, gives the final result. This sounds familiar, in fact, with a little tightening up of the math (computer scientists / mathematicians on here, help! :)), I bet it is identical to ρ, i.e. partial application.
What does this tell us? I'm actually a bit lost myself, so I'm not sure. Has all this reasoning been a pointless tautology of some kind? Who knows! Maybe you do. But I get the sense that the symmetry of sequences on opposite ends of this process for partial application vs currying tells us that these two processes are in some way inverse and yet isomorphic in some way. Maybe they can each model the other, which would explain our intuition of them as being similar. :waves hands furiously: I hope this has been at least "partially" edifying, or that it ... curries favor with somebody.