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_expr.cpp

@@ -246,7 +246,14 @@ auto HandleExprInPostfix(Context& context) -> void {
       // If not already diagnosed in the lexer, diagnose it here.
       if (token_kind != Lex::TokenKind::Error) {
         CARBON_DIAGNOSTIC(ExpectedExpr, Error, "expected expression");
-        context.emitter().Emit(*context.position(), ExpectedExpr);
+        CARBON_DIAGNOSTIC(ExpectedPattern, Error, "expected pattern");
+        llvm::SmallVector<StateKind, 2> state_kinds(
+            llvm::map_range(llvm::ArrayRef(context.state_stack()).take_back(2),
+                            [&](const Context::State& s) { return s.kind; }));
+        bool in_pattern = state_kinds == llvm::ArrayRef{StateKind::ExprPattern,
+                                                        StateKind::ExprLoop};
+        context.emitter().Emit(*context.position(),
+                               in_pattern ? ExpectedPattern : ExpectedExpr);
       }
 
       // Add a node to keep the parse tree balanced.