Parse dotted calls with dotcall head

[c42f]

Dotted call syntax parses into various forms which aren't really consistent. Especially, Expr is inconsistent about dotted infix calls vs dotted prefix calls. In this change we adopt a more consistent (and hopefully less mysterious!) parsing where dotted calls get their own dotcall head which is otherwise like the call head:

f.(a, b)  ==>  (dotcall f a b)
a .+ b    ==>  (dotcall-i a + b)
.+ b      ==>  (dotcall-pre + b)

In other cases where a dotted operator appears as an atom we split the dot from an operator, so .+ becomes (. +). Thus, for comparison chains and prefix calls, we have the following parsings:

a .< b < c  ==>  (comparison a (. <) b < c)
.*(a,b)     ==>  (call (. *) a b)

TODO: Unambiguously reconstructing the associated Expr in the latter cases is more challenging than expected and still requires some work.

Fix #90
Also incidentally fix #38

[c42f]

To quote the latest rebased commit message, I've punted on some non-dotcall related dotted operator splitting for now:

"There's other cases where it would also be consistent to split the dot
from the operator, but these are more challenging to convert back to a
compatible Expr so I've punted on these for now. For example, we'd like

.*(a,b)     ==>  (call (. *) a b)
.+(a,)      ==>  (call (. +) a)

but these are not yet implemented as we need to be able to distinguish
them from the likes of (.+)(a,) which the reference parser treats
differently from .+(a,)"