fix(genpc,parser,pcinterp): pcode wider regression sweep (Tier 1 #3)

Six more silent miscompiles in the pcode path, all uncovered by a
new pcode regression sweep that exercises the full PRG surface a
dynamic FrbCompile body could legitimately use.

  * **xBase-keyword shadowing of variable names.** parseIdentStmt
    and parseExprStmt's fallback switches consumed an entire line
    when the leading IDENT matched LABEL / REPORT / ACCEPT / INPUT
    / NOTE / etc. Those words are also extremely common LOCAL /
    PRIVATE names — `LOCAL label ; label := "x"` had the
    assignment swallowed because the switch didn't peek at the
    next token. Both switches now look at peek(1): an assignment
    operator, [], (, -, ++, --, or `.` means it's a variable /
    call / member access, not the xBase command, and we fall
    through to expression parsing. Real silent bug — bit
    test_frb_pcode_sweep's `LOCAL label` declaration.

  * **`arr[i]` indexing not implemented in genpc.** ast.IndexExpr
    fell through to the default PushNil path, so any indexed read
    in a pcode-mode body returned NIL. New case emits the array,
    the index, and PcOpArrayPush (the get-op; PcOpArrayPop is the
    set-op — naming follows Harbour convention). Hashes go
    through the same opcode, which already special-cases
    IsHash() in ops_collection.go.

  * **Hash literals not implemented in genpc + dispatch missing
    in pcinterp.** `{ "k" => v, ... }` fell to PushNil. Added
    HashLitExpr emit (Push key, Push value pairs, then PcOpHashGen
    with count). Also wired up the PcOpHashGen dispatch in
    execPcodeBody — it had been declared in pcode.go since the
    initial design but the case statement was never added, so
    even hand-written modules couldn't use hashes.

  * **`x++` / `x--` postfix were silent no-ops.** PostfixExpr fell
    to PushNil and the surrounding ExprStmt then popped the NIL.
    DO WHILE loops with `n--` couldn't terminate; FOR loops with
    `i++` in the body were broken too. New case: PushLocal +
    LocalAddInt(±1).

  * **BlockExpr (`{|p| body }`) wasn't compiled.** Eval(b, n)
    inside a pcode body returned NIL. Added: build the body in a
    sub-codebuffer with the block's params occupying its locals,
    emit PcOpRetValue at the end, then PushBlock with the
    serialized bytes. Format extended with a uint16 nParams field
    so the runtime's PcOpPushBlock dispatch can set
    PcodeFunc.Params correctly — without it, ExecPcode's
    Frame(0, 0) pulled none of Eval's args and the block saw
    every parameter as NIL.

  * **All g.locals accesses were case-sensitive.** PRG is case-
    insensitive, but the pcode generator stored block params via
    strings.ToUpper while every other lookup site (function decl,
    mid-decl, ForStmt, IdentExpr read, AssignExpr write,
    PostfixExpr) used the raw .Name. So `{|x| x*x }` stored "X"
    but read "x" and missed. Normalized: all insertions and all
    lookups now go through strings.ToUpper.

  * **SeqExpr in pcode** — added the matching emit for comma-
    separated expression lists in code blocks (`{|| a, b, c }`).
    Same shape as the gengo SeqExpr case from Wave 1.

Test fixture: tests/frb/test_frb_pcode_sweep.prg covers 14 shapes
(string ops, arithmetic, comparison chains, array indexing, DO
WHILE with postfix, nested IF, IIf, hash literal + indexing,
block + Eval, character iteration). All 14 pass. Wired into the
FRB runner — suite now stands at 7/7.

Other gates green:
  go test ./...      : PASS
  FiveSql2 SQL:1999  : 43/43
  Harbour compat     : 56/56
  std.ch suite       : 15/15
  FRB suite          : 7/7

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

compiler/parser/parser.go

@@ -1154,17 +1154,36 @@ func (p *Parser) parseIdentStmt() ast.Stmt {
 	// CLOSE / REINDEX / PACK / ZAP / UNLOCK / KEYBOARD / RUN are now
 	// rewritten by compiler/pp/std.ch into function calls before the
 	// parser sees them.
+	//
+	// Guard against shadowing variables — the keywords here (LABEL,
+	// REPORT, INPUT, NOTE, ...) are also extremely common LOCAL/PRIVATE
+	// names. If the very next token is an assignment / index / paren /
+	// alias-arrow operator, the user is doing a variable assignment or
+	// function call, not invoking the xBase command — fall through to
+	// expression parsing. This was a real silent bug: `LOCAL label` +
+	// `label := "x"` had the assignment swallowed by the LABEL case
+	// because the no-op consumed-to-EOL path doesn't care about :=.
 	switch upper {
 	case "LABEL", "REPORT", "ACCEPT", "INPUT",
 		"RELEASE", "SAVE", "RESTORE",
 		"DIR", "STORE", "NOTE", "TEXT", "ENDTEXT",
 		"WITH", "CLEAR":
-		p.advance()
-		for p.current.Kind != token.NEWLINE && p.current.Kind != token.EOF {
+		switch p.peekAt(1) {
+		case token.ASSIGN, token.PLUSEQ, token.MINUSEQ, token.STAREQ,
+			token.SLASHEQ, token.PERCENTEQ, token.POWEREQ,
+			token.LBRACKET, token.LPAREN, token.ARROW,
+			token.INC, token.DEC,
+			token.DOT:
+			// Looks like a variable / call / member-access — not
+			// the xBase command. Fall through.
+		default:
 			p.advance()
+			for p.current.Kind != token.NEWLINE && p.current.Kind != token.EOF {
+				p.advance()
+			}
+			p.expectEndOfStmt()
+			return &ast.ExprStmt{X: &ast.LiteralExpr{Kind: token.NIL_LIT, Value: "NIL"}}
 		}
-		p.expectEndOfStmt()
-		return &ast.ExprStmt{X: &ast.LiteralExpr{Kind: token.NIL_LIT, Value: "NIL"}}
 
 	case "FIVE_GODUMP__":
 		// GoDump is a Decl, wrap as ExprStmt for statement context
@@ -1229,13 +1248,25 @@ func (p *Parser) parseExprStmt() ast.Stmt {
 			"RELEASE", "SAVE", "RESTORE",
 			"DIR", "STORE", "NOTE", "TEXT", "ENDTEXT",
 			"WITH", "CLEAR":
-			// Consume entire line — these are complex multi-word commands
-			p.advance()
-			for p.current.Kind != token.NEWLINE && p.current.Kind != token.EOF {
+			// Same shadowing-guard as parseIdentStmt — see comment
+			// there. Without this, `LOCAL label ; label := "x"` had
+			// the assignment swallowed.
+			switch p.peekAt(1) {
+			case token.ASSIGN, token.PLUSEQ, token.MINUSEQ, token.STAREQ,
+				token.SLASHEQ, token.PERCENTEQ, token.POWEREQ,
+				token.LBRACKET, token.LPAREN, token.ARROW,
+				token.INC, token.DEC,
+				token.DOT:
+				// Variable / call / member-access — fall through.
+			default:
+				// Consume entire line — these are complex multi-word commands
 				p.advance()
+				for p.current.Kind != token.NEWLINE && p.current.Kind != token.EOF {
+					p.advance()
+				}
+				p.expectEndOfStmt()
+				return &ast.ExprStmt{X: &ast.LiteralExpr{Kind: token.NIL_LIT, Value: "NIL"}}
 			}
-			p.expectEndOfStmt()
-			return &ast.ExprStmt{X: &ast.LiteralExpr{Kind: token.NIL_LIT, Value: "NIL"}}
 		}
 	}