Hand out the child of a rule that only forwards it - #7

An expression like the literal `42` is parsed through the full operator
precedence hierarchy: `Expression`, `LambdaArrowExpression`, `LogicalOr`,
`LogicalAnd`, `LogicalNot`, `Is`, `IsDistinctFrom`, `Comparison`,
`BetweenInLike`, `OtherOperator`, `Bitwise`, `Additive`, `Multiplicative`,
`Exponentiation`, `Collate`, `AtTimeZone`, `Prefix` and `BaseExpression`.
Every one of those rules has the shape `X <- Y Tail*` and a transformer that
returns Y's result untouched when no tail matched, yet each level allocated
its own `ListParseResult` wrapper around the single child and later cost a
transform frame just to unwrap it again. For a query with a few thousand
literals that is tens of thousands of parse results and transform processes
carrying no information. The hierarchy is the worst case but not the only one:
a hundred more rules exist only to name something and forward it.

Rules can now be registered with `MatcherFactory::AddCollapsibleRule`. When
such a rule finishes matching and exactly one child produced a result, with
every other child an optional that matched nothing, `ListMatchProcess` hands
out that child's parse result in place of its own and marks it `collapsed`.
`TransformInput::GetRule` then transforms a collapsed result with its own
rule even when the parent asked for the collapsed rule, which is correct
precisely because the collapsed rule would have returned the child's value
unchanged. A result handed out this way has to carry a rule of its own, since
it is transformed as itself; where it does not, the rule keeps its frame.

Which rules those are is read off the transformers rather than listed, because
a list of a hundred names drifts from the grammar. Two shapes are recognised
once the trampolines have been emitted:

- a generated finalizer that takes its one child result and returns it, which
  is what a rule that only names something compiles to, and
- a hand-written transformer that moves its operand into a local and returns
  that local when the optional tail did not match, which is what every level of
  the precedence hierarchy is written as.

That accounts for 120 of the 123 rules, the 18 precedence levels among them.
`grammar_types.yml` is left naming three that neither shape catches, each with
the reason: `LogicalOrExpression` and `LogicalAndExpression` forward inside a
shared `FoldConjunctionExpression` helper rather than in their own body, and
`PrefixExpression` has no hand-written transformer to read the shape off.