Fix dot_alias and dot_identifier translations

matchedExpressionDotOperation allowed any matchedExpression for the
right operand when it should have only allowed ALIAS or IDENTIFIER.
Transliterating dot_alias and dot_identifier leads to left-recursive
that is unterminable because the parser generator can only handle
left-recursion in expressions that are direct children, so dot_alias is
split into matchedExpressionDotAlias and ALIAS in maxExpression.
maxExpression along with accessExpression had matchedExpression- added
to their name to signify they are only meant for use as descendants of
matchedExpression and not direct transliterations anymore.
dot_identifier is split into matchedExpressionDotIdentifier and
identifierExpression.  There can't be an rule representing
no_parens_one_expression as it will lead to an indirect descendent
starting with matchedExpression, which leads to non-terminating
left-recursion.
Test matchedExpressionDotIdentifier
call_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw

Add no_parens_expression as noParenthesesExpression to expression.  Use
`(matchedExpressionDotIdentifier | identifierExpression)` for
`dot_identifer` in `no_parens_expr -> dot_identifier
call_args_no_parens_many_strict`.  `dot_op_identifer` in `no_parens_expr
-> dot_op_identifier call_args_no_parens_many_strict` does not need to
be implemented because `op_identifier` is unnecessary.
`call_args_no_parens_many_strict` is implemented as
callArgumentsNoParenthesesManyStrict, but without error handling.
`call_args_no_parens_many` in
`call_args_no_parens_many_strict -> call_args_no_parens_many` is
callArgumentsNoParenthesesMany.  Only the `call_args_no_parens_many ->
matched_expr ',' call_args_no_parens_kw` clause is implemented.
`call_args_no_parens_kw -> call_args_no_parens_kw_expr` and
`call_args_no_parens_kw -> call_args_no_parens_kw_expr ','
call_args_no_parens_kw` are in callArgumentsNoParenthesesKeywords as
`callArgumentsNoParenthesesKeywordsExpression (COMMA EOL*
callArgumentsNoParenthesesKeywordsExpression)*`.
`call_args_no_parens_kw_expr` is
callArgumentsNoParenthesesKeywordsExpression.
`call_args_no_parens_expr` from `call_args_no_parens_kw_expr -> kw_eol
call_args_no_parens_expr` is callargumentsNoParenthesesExpression, but
without error handling.
`call_args_no_parens_many -> call_args_no_parens_comma_expr`

Add `| callArgumentsNoParenthesesExpression` to
`callArgumentsNoParenthesesMany` to cover `call_args_no_parens_many ->
call_args_no_parens_comma_expr`.  `call_args_no_parens_comma_expr ->
matched_expr ',' call_args_no_parens_expr` and
`call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ','
call_args_no_parens_expr` are converted to
`callArgumentsNoParenthesesKeywords ::=
callArgumentsNoParenthesesKeywordsExpression (COMMA EOL*
callArgumentsNoParenthesesKeywordsExpression)*`.
`call_args_no_parens_expr -> matched_expr` and `call_args_no_parens_expr
-> empty_paren` are converted to `callArgumentsNoParenthesesExpression
::= matchedExpression | emptyParentheses`.

When testing the above additions, bugs were found in using
matchedExpressionDotIdentifier: the generated parser used just the plain
matchedExpression due to matchedExpressionDotIdentifier only existing as
a child of matchedExpression.  This led to too many things, such as a
CHAR_TOKEN counting as a valid function name, which it is not, so
`noParenthesesExpression`'s first term was rewritten to replicate all
parts of matchedExpression that are allowed to be qualified function
identifiers.

There is still an outstanding bug that `a + b in c - d` parses as `a(+b)
in (c - d)`.  I believe this due to be that I move
noParenthesesExpression before matchedExpression so that
identifierExpression would not match before noParenthesesExpression, but
this bug indicates that identifierExpression will likely need to be
extracted from matchedExpression completely so that function calls
without arguments are parsed after matchedExpression or
noParenthesesExpression.
Only allow many arguments in callArgumentsNoParenthesesMany

I accidently used `*` insted `+`, so callArgumentsNoParenthesesMany was
allowed to have a single positional argument.  Correcting to
`matchedExpression (COMMA EOL* callArgumentsNoParenthesesExpression)+`
fixed the issues with `a + b in c - d` parsing as `a(+b) in c - d` also.
`call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw`

Combined `call_args_no_parens_many -> call_args_no_parens_comma_expr`
that was already callArgumentsNoParenthesesCommaExpression and
`call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ','
call_args_no_parens_expr` into `callArgumentsNoParenthesesCommaExpression
(COMMA EOL* callArgumentsNoParenthesesKeywords)?`.  In order to get the
keywordKey to work in the first keyword pair, I need to check that
matchedExpression was succeeded by KEYWORD_PAIR_COLON in
`callArgumentsNoParenthesesExpression`.
call_args_no_parens_expr -> no_parens_expr : throw_no_parens_many_strict('$1').

Implement the error throwing done by the compiler as an error
inspection, "Elixir/Ambiguous nested calls".  noParenthesesExpressions
are allowed in callArgumentsNoParenthesesExpression and the error is
only highlighted at inspection time as this is a recoverable error for
the grammar parser if not for the compiler.
call_args_no_parens_many_strict -> empty_paren : throw_no_parens_strict('$1')

Create a new inspection class, NoParenthesesStrict, that will mark
errors to mirror throw_no_parens_strict.  To ease the fact that multiple
rules will need to be matched for the converted
`call_args_no_parens_many_strict`, all rules that would call
`throw_no_parnes_strict` will be children of `noParenthesesStrict`.  It
is currently `noParenthesesStrict ::= emptyParentheses`.
call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : throw_no_parens_strict('$1').

Add `OPENING_PARENTHESIS callArgumentsNoParenthesesKeywords
CLOSING_PARENTHESIS` to noParenthesesStrict so that the
NoParenthesesStrict inspection can mark them as an error.
Rename test to match code under test
Fix case typo
call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren

Add `callArgumentsNoParenthesesMany` inside the parentheses in
noParenthesesStrict, to yield the final `noParenthesesStrict ::=
emptyParentheses | OPENING_PARENTHESIS (callArgumentsNoParenthesesKeywords |
callArgumentsNoParenthesesMany) CLOSING_PARENTHESIS`.
Add keywords in parentheses to NoParenthesesStrict examples
Add `Positional arguments in Parentheses` to NoParenthesesStrict docs
Differentiate between identifier( and identifier<space>(

After an identifier, check if it is immediately followed by `(`.  If `(`
does follow, return a zero-width `CALL` token before the
`OPENING_PARENTHESIS` token for the `(`.
Quick fix for NoParanthesesStrict inspection

Alt+Enter on an ambiguous parentheses error will remove the space before
the space between the function name and the parentheses, which will fix
the annotated error.
matched_expr -> capture_op_eol no_parens_expr

Merge `matched_expr -> capture_op_eol matched_expr`, which already exists
as `matchedExpressionCaptureOperation ::= CAPTURE_OPERATOR EOL*
matchedExpression`, and `matched_expr -> capture_op_eol no_parens_expr`
into `matchedExpressionCaptureOperation ::= CAPTURE_OPERATOR EOL*
(noParenthesesExpression | matchedExpression)`.  Rearranged Capture.txt
so that the failing association operator test was at the end of the file
so it doesn't mask failures in the other operator precedence.
Correct precedence of &<number>

&<number> is higher precedence than &<match_expr> or &<no_parens_expr>
when run through `Code.string_to_quoted`, so
`matchedExpressionCaptureOperation` needs to add `number` to it's
ordered choice before `noParenthesesExpression` so that `&1 + &2` parses
as `(&1) + (&2)` instead of `&(1 + (&2))`, but `&a + &b` still parses as
`&(a + (&b))`.
Remove numberCaptureOperation

Not needed because matchedExpressionCaptureOperation will cover
numberCaptureOperation.
matched_expr -> at_op_eol no_parens_expr

Add `matchedExpressionNoParenthesesExpressionAtOperation` to
`matchedExpression` before `matchedExpressionAtOperation` because
`noParenthesesExpression` matches a superstring of `matchedExpression`.
`matchedExpressionNoParenthesesExpressionAtOperation` is prefixed
`matcheExpression` because it needs to extend `matchedExpression` to
prevent unresolved left-recursion in the generated parser.  The rule can
still be written in the obvious way as
`matchedExpressionNoParenthesesExpressionAtOperation ::= AT_OPERATOR
EOL* noParenthesesExpression`, it's the extension of matchedExpression,
which is crucial.  This approach should be generalized back to
`matchedExpressionCaptureOperation` to split it into a number,
noParenthesesExpression and matchedExpression version.
`matchedExpressioNCaptureOperation` only works now as written because it
is the first ordered choice in matchedExpression.  The approach should
also be used for `matched_expr -> unary_op_eol no_parens_expr`.