perf(FiveSql2): FieldGet peephole + DBFArea devirt — WHERE at ~1.15x raw RDD

Two stacked optimizations land on the SqlScan hot path. Combined
effect on the 50k-row benchmark:

                       Before    After   vs raw
  Numeric WHERE        10.2ms    7.8ms   1.15x
  String WHERE         10.5ms    7.9ms   1.15x
  No WHERE              9.2ms   10.0ms   1.45x
  Raw RDD baseline      6.8ms    6.8ms   1.00x

WHERE-predicate paths are now within 15% of the raw Harbour-style
RDD scan loop. The no-WHERE path is unchanged (slight jitter from
the added devirt branch); FieldGet peephole doesn't apply there.

--- Optimization 1: PcOpFieldGet peephole ---

Adds a new pcode opcode `PcOpFieldGet <fieldIdx>` (0x46) that skips
the usual PushSymbol+Function+Frame+FieldGet-RTL+EndProc chain and
calls a direct field getter closure instead. genpc recognizes the
shape `FieldGet(<int-literal>)` during emitCall and emits the
specialized opcode automatically — no SQL-side API change.

Integration:
  * hbrt.Thread.FastFieldGetter  — hot-path closure set by scan loops.
                                   Non-nil → pcode bypasses dispatch.
                                   Nil → pcode resolves FIELDGET via
                                   the RTL symbol table (correctness
                                   fallback for any other callers).
  * compiler/genpc/genpc.go      — peephole in emitCall.
  * hbrt/pcinterp.go             — PcOpFieldGet handler.

This alone cut numeric WHERE from 10.2 → 7.9ms: eliminated roughly
one full Frame/EndProc + RTL dispatch per row × 50k rows.

--- Optimization 2: DBFArea devirtualization ---

SqlScan type-asserts the workarea to *dbf.DBFArea once and runs a
dedicated loop that calls GoTop/EOF/Skip/GetValue directly on the
concrete type. Go's compiler inlines these, skipping the interface
vtable per row. Non-DBF drivers still work via the generic Area
branch.

The FastFieldGetter closure also captures *DBFArea directly in the
DBF branch, so the WHERE predicate side of the hot loop is now
entirely devirtualized: no interface dispatch between the pcode
dispatch loop and the DBF record buffer.

Validation:
  - FiveSql2 43/43
  - Harbour compat 51/51
  - go test ./... ALL PASS

Remaining gap to raw RDD on no-WHERE (~1.45x) is dominated by the
two-column row construction + ArraySlab + flat backing bookkeeping
that the raw loop doesn't do. Going below that requires changing
the SQL engine's result shape — out of scope here.

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

compiler/genpc/genpc.go

@@ -12,6 +12,7 @@ import (
 	"five/compiler/token"
 	"five/hbrt"
 	"math"
+	"strconv"
 	"strings"
 )
 
@@ -484,6 +485,19 @@ func (g *generator) emitBinaryOp(op token.Kind) {
 
 func (g *generator) emitCall(e *ast.CallExpr) {
 	if ident, ok := e.Func.(*ast.IdentExpr); ok {
+		// Peephole: FieldGet(<int literal>) → PcOpFieldGet <idx>.
+		// Skips the entire PushSymbol + Function + Frame + RTL path in
+		// favor of a direct workarea field access. Huge win for WHERE
+		// predicates on scan loops where this is the per-row hot op.
+		if strings.EqualFold(ident.Name, "FieldGet") && len(e.Args) == 1 {
+			if lit, ok := e.Args[0].(*ast.LiteralExpr); ok && lit.Kind == token.INT {
+				if n, err := strconv.Atoi(lit.Value); err == nil && n > 0 && n <= 0xFFFF {
+					g.emit(hbrt.PcOpFieldGet)
+					g.emitU16(uint16(n))
+					return
+				}
+			}
+		}
 		g.emitString(hbrt.PcOpPushSymbol, strings.ToUpper(ident.Name))
 		g.emit(hbrt.PcOpPushNil)
 		for _, arg := range e.Args {