Fix an unparser error on expressions like -(1 + 2) - #262

…1434)

* parser: parenthesize unary operands that would reparse differently

visitCallUnary decides whether to parenthesize its operand with
isComplexOperator, which only returns true for a call with two or more
arguments. It was added by #262 to fix `-(1 + 2)`, and never covered an
operand that is itself a unary call or a negative numeric literal.

Two grammar rules make that unsound. `unary` parses a run of leading '-'
or '!' tokens as one expression and drops the operator when the count is
even, and `literal` binds a leading '-' into an int or double constant.
So the unparser emits text that either means something else or does not
parse:

    !(!a)                     -> !!a                     reparses as a
    -(-a)                     -> --a                     reparses as a
    -(-(-a))                  -> ---a                    reparses as -a
    -(!a)                     -> -!a                     syntax error
    !(-a)                     -> !-a                     syntax error
    -(-1)                     -> --1                     reparses as 1
    -(-9223372036854775808)   -> --9223372036854775808    invalid int literal

Since AstToString is the public way to render a checked AST back to
source, round-tripping changes evaluation: `-(-x)` with x = MinInt64 must
raise integer overflow but returns -9223372036854775808 afterwards, and
`!(!a)` on a non-bool must raise no such overload but returns a value.

Parenthesize an operand that is a single-argument logical-not or negate
call, or a negative int or double literal. math.Signbit is used for
doubles so negative zero is covered too.

* parser: simplify the unary operand check to the function name

The member-function and argument-count guards cannot change the outcome,
since the logical-not and negate operator names are unary by definition.