Compress YYINITIAL, INTERPOLATION actions

Remove blank lines not used for other state actions.
Fix order of bnf rules
Unary Operator

Unary forms of `not`, `~~~`, `!`, `+`, `-`, and `^`.
Parser tests for unary operators
Lexer tests for unary operators
Hat operator

The hat operator (^^^) is defined as bitwise or in the Bitwise module in
standard library.
Fix operator precedence

Ensure that unary operators have higher precedence than the hat
operator.  Ensure the correct operands are used for unary and hat so
that parser doesn't error out with unbalanced.  Special case hatOperand
to be either unaryOperation or unaryOperand.  This allows any expression
to degrade to just a unaryOperand, which is the old expression rules of
atom, CHAR_TOKEN, NUMBER, charListHeredoc, quote, sigil, and
stringHeredoc, so that operatorless operands don't all become bad
characters until all operators are finished.
Multiplication Operators (* and /)
Fix operator precedence and grouping

Restructure how multiplication wraps hat wrap unary wraps value.  This
is based on the parser bnf for intellij-haxe.  Have atoms, binary and
unary options, and values extend expression to collapse tree.  Have
binary operations, hat and multiplication, extend a fake
binaryOperation, which allows to access the left and right child
expressions.  Override name of unaryOperation to be the user-facing name
for each token/rule encapsulated by unaryOperation.
Addition (+/-) operations

Break out '+' and '-' from UNARY_OPERATOR and put them in DUAL_OPERATOR.
It's called dual because '+' and '-' can be parsed as either a unary or
a binary operator.  From experiments with Code.string_to_quoted/1, it
appears that dual operators are binary when there is no EOL between the
first argument and the operator and unary otherwise.
Remove need for custom child expressions and `left`

List operations and value from lower to higher precedence and remove the
`left` modifier on operations, which removes the need for operation
lists.  **NOTE: it is crucial that the operations extend expression with
`extends("(addition|hat|multiplication)Operation")=binaryExpression`,
because binaryOperation then extends expression, which is the recursion
point.
Two Operator

Two Operator is the term for the right-associative operators `++`, `--`,
`..`, and `<>`.
Arrow operator

`<<<`, `<<~`, `<|>`, `<~>`, `>>>`, `~>>`, `<~`, `|>`, and `~>`.
Fix comment to match parse
Relational operations

`<`, `<=`, `>`, and `>=`.
Remove redundant tokens form TWO_TOKEN_OPERATOR

"<=" and ">=" are already in {TWO_TOKEN_RELATIONAL_OPERATOR} so they
don't need to be explicit in TWO_TOKEN_OPERATOR.
Comparison operations

`==`, `!=`, `=~`, `===`, and `!==`.
And operations

`&&&`, `and`, and `&&`.
Or Operation

`|||`, `||`, and `or`.
Fix or + and operation test