Support for parsing expression patterns (#6977)

When parsing a pattern, if we encounter something that isn't pattern
syntax, try parsing as an expression instead. We only need one-token
lookahead to distinguish pattern syntax from expression syntax.

Track a precedence group through pattern parsing so that we can allow
different kinds of expressions in a top-level pattern (such as the
operand of `let`) and in a nested pattern (such as a subpattern of a
tuple pattern or within grouping parens). For example, we do not allow
`case if ...`, and for now I've chosen to also not allow logical or
relational operators at the top level of a pattern, so `case 1 + 1` is
OK, but `case 1 == 1` and `case true and false` require parentheses.
This decision should be ratified or revisited by a design proposal.

Very basic check support is also provided, only sufficient to form an
`ExprPattern` instruction and nothing beyond that. For now, all pattern
matching against an `ExprPattern` fails with a TODO error. To support
that, I've switched from calling `BeginSubpattern` in the parent handler
of a pattern and `EndSubpatternAs*` in the pattern handler itself to
calling both functions in parent handlers, with `EndSubpattern`
converting an expression into an expression pattern where needed.

Depends on #6976.

Assisted-by: Gemini via Google Antigravity

toolchain/parse/handle_pattern_list.cpp

@@ -13,9 +13,11 @@ static auto HandlePatternListElement(Context& context, StateKind pattern_state,
   auto state = context.PopState();
 
   context.PushStateForPattern(finish_state_kind, state.in_var_pattern,
-                              state.in_unused_pattern);
+                              state.in_unused_pattern,
+                              state.ambient_precedence);
   context.PushStateForPattern(pattern_state, state.in_var_pattern,
-                              state.in_unused_pattern);
+                              state.in_unused_pattern,
+                              state.ambient_precedence);
 }
 
 auto HandlePatternListElementAsTuple(Context& context) -> void {
@@ -58,7 +60,8 @@ static auto HandlePatternListElementFinish(Context& context,
 
   if (list_token_kind == Context::ListTokenKind::Comma) {
     context.PushStateForPattern(param_state_kind, state.in_var_pattern,
-                                state.in_unused_pattern);
+                                state.in_unused_pattern,
+                                state.ambient_precedence);
   }
 }
 
@@ -90,12 +93,13 @@ static auto HandlePatternList(Context& context, NodeKind node_kind,
 
   context.PushStateForPattern(
       empty ? finish_state_empty : finish_state_nonempty, state.in_var_pattern,
-      state.in_unused_pattern);
+      state.in_unused_pattern, state.ambient_precedence);
   context.AddLeafNode(node_kind, open_token);
 
   if (!empty) {
     context.PushStateForPattern(param_state, state.in_var_pattern,
-                                state.in_unused_pattern);
+                                state.in_unused_pattern,
+                                PrecedenceGroup::ForTopLevelExpr());
   }
 }