right-associative implicit call

[As discussed on the mailing list](https://groups.google.com/d/topic/metascript/Nf0PBBht_zs) here are some changes to make the *space operator* have less precedence than member access and be right associative.

    a b        ; a(b)
    a b c      ; a(b(c))
    a b.c      ; a(b.c)
    a.b c.d    ; a.b(c.d)
    a(b c)(d) ; a(b(c))(d)

I certainly prefer this syntax, the right associativity works like in coffeescript and seems to work quite well to interact with Javascript code, which doesn't apply currying normally. Although if you prefer to keep it with left associativity I could certainly live with that if it still respects member precedence.
I had it lowered at the beginning, just over assignment, but the syntax wasn't working very well when experimenting with, I guess the problem was basically that if the implicit call is just for arity-1 functions, by lowering it the following was strange:

    a b + c d   ; expected: (a b) + (c d) but was: (a (b+c))(d)

So I decided to change implicit to argument separator instead of call operator. The result was very nice actually, it worked like bash/haskell and had a very nice side effect: parens are just used for grouping/disambiguation/tuples not calls, so it becomes easier to reason about precedence:

    a b c d     ; a(b, c, d)
    a b + c d  ; a(b+c, d)
    a (b c) + d  ; a(b(c) + d)
    a (b c).d 10  ; a(b(c).d, 10)
    a 10 x -> !x  ; a(10, (x) -> !x)

But I guess that's going too far from the current syntax, needing more experimentation to validate, and IMO has the risk of allowing users to write very difficult to understand code if they try to avoid using parens at all costs. Perhaps it would be better implemented as a macro that unwraps the calls?

    a <- b (c+d) e  ; a(b, c+d, e)

So in essence I think the current approach is good enough for most use cases: simple arity-1 calls with a tag/member/call argument, while still being compatible with c/javascript like explicit parens when we need to use other operators.