Lambda the Ultimate

Abstraction is the key, at least somewhat. I also find sections of (.) very difficult to comprehend, but some better names make things a little clearer.

result = (.)
argument = flip (.)

The insight is that (.) transforms a function to operate on the result of another function, while flip (.) transforms a function to operate on the argument of another function. Since all functions are curried, chains of these two transformations cover all the possibilities. Your first example:

(((f.).).) g
  == (result.result.result) f g 
  == \x y z -> f (g x y z)

Your second example:

(.(.(.f))) g
  == (argument.argument.argument) f g
  == \ a -> g (\ b -> a (\ c -> b ((+) c))) -- or something?

If f is a function a -> b, then (argument.argument.argument) f will transform a function g of type:

(((b -> c2) -> c1) -> c)

into a function of type:

(((a -> c2) -> c1) -> c)

In English, it will apply f to the argument of the argument of the argument of g.

Of course, that's not as useful as the first example, because while multi-argument curried functions are common, functions (like this second g) that expect arguments with types like (((a -> b) -> c) -> d) are less so.

In general, chains of "argument" aren't so common, but it's very common to see chains like "argument.result.result.result", which will apply a function to the 4th (curried) argument of another function.

Here are a few blog posts to get you started, one from me and a couple from Conal Elliott: 1, 2. Point-free style can be comprehensible and useful when you work with the right tools, but obfuscation is obfuscation in any language...