feat(parser)!: #{ record-literal sigil; { is always a block [#218]

Structurally removes the block-vs-record-literal ambiguity (#215
families C+D) with no lookahead heuristic, per the owner-approved
Rust-like model:

  - `{` in expression position is ALWAYS a block.
  - record/struct literals use `#{ … }` (anonymous `#{ x: 1 }` and
    typed `Foo #{ x: 1 }`).
  - record *patterns* unchanged (pattern position has no block
    alternative — no ambiguity there).

Changes: HASH_LBRACE token (token.ml), `#{` lexer rule (lexer.ml;
`#` was previously unused so longest-match is collision-free), both
ExprRecord productions rerouted LBRACE -> HASH_LBRACE (parser.mly).

Menhir conflicts on origin/main (a45b021): 72 S/R + 10 R/R
                                  after:  68 S/R +  7 R/R   (-4 / -3)
Build clean. BREAKING: legacy `{ … }` record syntax no longer parses;
the codemod-migrated repo `.affine` files land in the same PR so the
253/257 gate stays green.

Refs #218 #215

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

lib/lexer.ml

@@ -183,6 +183,9 @@ let rec token state buf =
   | "-=" -> MINUSEQ
   | "*=" -> STAREQ
   | "/=" -> SLASHEQ
+  (* `#{` opens a record/struct literal (#218); longest-match, and `#` has
+     no other lexer rule, so this never shadows a single-char token. *)
+  | "#{" -> HASH_LBRACE
 
   (* Single-char tokens *)
   | '(' -> LPAREN

lib/parse_driver.ml

@@ -76,6 +76,7 @@ let to_menhir_token (tok : Token.t) : Parser.token =
     | Token.LPAREN -> Parser.LPAREN
     | Token.RPAREN -> Parser.RPAREN
     | Token.LBRACE -> Parser.LBRACE
+    | Token.HASH_LBRACE -> Parser.HASH_LBRACE
     | Token.RBRACE -> Parser.RBRACE
     | Token.LBRACKET -> Parser.LBRACKET
     | Token.RBRACKET -> Parser.RBRACKET

lib/parser.mly

@@ -66,6 +66,10 @@ let rec effect_union_of_list = function
 
 /* Punctuation */
 %token LPAREN RPAREN LBRACE RBRACE LBRACKET RBRACKET
+/* `#{` opens a record/struct literal (#218). `{` is ALWAYS a block in
+   expression position — this structurally removes the block-vs-record
+   ambiguity (#215 families C+D) with no lookahead heuristic. */
+%token HASH_LBRACE
 %token COMMA SEMICOLON COLON COLONCOLON DOT DOTDOT
 %token ARROW FAT_ARROW PIPE AT UNDERSCORE BACKSLASH QUESTION
 
@@ -768,10 +772,10 @@ expr_primary:
      ordinary parameter binding named "self". */
   | SELF_KW { ExprVar (mk_ident "self" $startpos $endpos) }
   | name = lower_ident { ExprVar (mk_ident name $startpos $endpos) }
-  /* Struct literal: `Point { x: v, y: w }`.  Must come before the plain
-     upper_ident production so Menhir shifts LBRACE rather than reducing
-     upper_ident to ExprVar when the next token is LBRACE. */
-  | _ty = upper_ident LBRACE b = expr_record_body RBRACE
+  /* Struct literal: `Point #{ x: v, y: w }` (#218).  The `#{` sigil makes
+     this unambiguous against the plain `upper_ident` production and against
+     a following block, so no LBRACE-shift heuristic is needed any more. */
+  | _ty = upper_ident HASH_LBRACE b = expr_record_body RBRACE
     { ExprRecord { er_fields = fst b; er_spread = snd b } }
   | name = upper_ident { ExprVar (mk_ident name $startpos $endpos) }
   | ty = upper_ident COLONCOLON variant = upper_ident
@@ -787,11 +791,12 @@ expr_primary:
   /* Arrays */
   | LBRACKET es = separated_list(COMMA, expr) RBRACKET { ExprArray es }
 
-  /* Records — use a recursive rule (expr_record_body / expr_record_rest) to
-     avoid the LALR(1) greedy-separator conflict that arises when a ROW_VAR
-     spread like `..record` follows a COMMA that `separated_list` has already
-     consumed expecting another record_field. */
-  | LBRACE b = expr_record_body RBRACE
+  /* Anonymous record `#{ f: v, ..spread }` (#218).  Uses a recursive rule
+     (expr_record_body / expr_record_rest) to avoid the LALR(1) greedy-
+     separator conflict that arises when a ROW_VAR spread like `..record`
+     follows a COMMA that `separated_list` has already consumed expecting
+     another record_field. */
+  | HASH_LBRACE b = expr_record_body RBRACE
     { ExprRecord { er_fields = fst b; er_spread = snd b } }
 
   /* Block */

lib/token.ml

@@ -72,6 +72,7 @@ type t =
   | LPAREN
   | RPAREN
   | LBRACE
+  | HASH_LBRACE
   | RBRACE
   | LBRACKET
   | RBRACKET
@@ -186,6 +187,7 @@ let to_string = function
   | LPAREN -> "("
   | RPAREN -> ")"
   | LBRACE -> "{"
+  | HASH_LBRACE -> "#{"
   | RBRACE -> "}"
   | LBRACKET -> "["
   | RBRACKET -> "]"