perf: RTL Go-native migration — 27 optimizations, DML up to 70-90x

Systematic pass through PRG hot paths, promoting them to Go RTL while
preserving Harbour/FiveSql2 semantics. Full log in
docs/RTL-Go-Native-Migration.md.

Bench (bench_sql) vs 2026-04-08 baseline
 - B1  SELECT *             2,192 → 114   µs   (19x)
 - B6  INNER JOIN           9,291 → 233   µs   (40x)
 - B7  CTE simple           8,037 → 129   µs   (62x)
 - B9  ROW_NUMBER           3,705 → 265   µs   (14x)
 - B10 RANK PARTITION       4,748 → 309   µs   (15x)
 - B12 INSERT (WA cache)    4,319 →  63   µs   (69x)
 - B13 UPDATE (WA cache)    6,144 →  68   µs   (90x)
 - B15 CTE+WIN+JOIN        18,395 → 1,873 µs   (10x)

Infrastructure
 - HbHash O(1) Index preserving insertion order (Harbour KEEPORDER)
 - HbDeepClone Go RTL (scalar-sharing, immutable hash keys)
 - MEMRDD auto-imported via gengo; all Five programs get mem:name driver
 - SQL plan + pcode caches (s_hPlanCache, s_hDmlPcodeCache)
 - Opt-in SqlWACacheEnable — dbUseArea/Close/Commit batched for DML

SQL engine
 - FiveSql2 lexer ported to Go (byte FSM) with combined automatic
   template parameterization (literals → ?, concat queries share plan)
 - Go RTL: SqlDistinct, SqlGroupRows, SqlWindowPartitions,
   SqlWindowSortPartition, SqlWindowAssignRank, SqlComputeAggSimple,
   SqlBulkInsert, SqlBulkUpdate, SqlExprHasAgg, SqlEvalHaving
 - CTE / subquery / driving-table materialize paths use MEMRDD
 - SqlCoerce/SqlCmp/SqlIsTrue helpers moved from PRG to Go
 - SqlBulkUpdate defers Flush when WA cache active (APFS fsync was
   dominant B13 cost — 1.6ms/call → gone)

Correctness fixes uncovered during migration
 - ASort default path now sorts dates/logicals/timestamps (was no-op)
 - ORDER BY default NULL placement matches PRG SqlRowCompare across
   Go fast path; explicit NULLS FIRST/LAST honored by both paths
 - SqlBulkUpdate respects EXCLUSIVE vs SHARED mode record locks
 - SqlCmp/SqlCmpEq normalize NumInt vs Double (caught by test 6b)

Verification
 - go test ./...              ALL PASS
 - FiveSql2 test_sql1999      43/43
 - tests/compat_harbour       56/56 (+5 new: ASort dates/logicals,
                              AScan int cross-type)
 - Regression test test_null_order.prg for ORDER BY NULL ordering

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

_FiveSql2/src/TFiveSQL.prg

@@ -14,6 +14,19 @@
 #include "hbclass.ch"
 #include "FiveSqlDef.ch"
 
+/* Plan cache: cSQL → parsed hQuery.
+ *
+ * The FiveSql2 parser runs lex + Pratt-style AST build per call; for
+ * repeated identical SQL (typical in report / loop / benchmark workloads)
+ * this is pure overhead. We cache the pristine parse result keyed by
+ * the raw SQL text and hand every subsequent call a deep clone via
+ * HbDeepClone so in-place mutations (SqlFoldConst, aTables rewriting)
+ * during Run() never corrupt the cached tree.
+ *
+ * Cached entries live until process exit; distinct SQL text count is
+ * bounded by the caller's template set, so LRU is deferred. */
+STATIC s_hPlanCache := { => }
+
 CLASS TFiveSQL
 
    DATA oLexer
@@ -40,20 +53,50 @@ RETURN SELF
 METHOD Execute( cSQL, bBlock ) CLASS TFiveSQL
 
    LOCAL aTokens, hQuery, aResult
+   LOCAL aLex, cKey, aParams
 
-   /* Parse — no caching (plan trees are mutated during execution) */
-   ::oLexer := TSqlLexer():New( cSQL )
-   ::oLexer:Tokenize()
-   aTokens := ::oLexer:GetTokens()
+   /* Fast path: no explicit aParams → single Go RTL lex+normalize call
+    * (SqlLexAndExtractTemplate). Returns {aTokens, cKey, aParams}; the
+    * tokens already have TK_TEXT/TK_NUM replaced with TK_QMARK, so
+    * TSqlParser2 sees the template shape and emits ND_PAR references
+    * against the extracted aParams. */
+   IF Empty( ::aParams )
+      aLex := SqlLexAndExtractTemplate( cSQL )
+      aTokens := aLex[ 1 ]
+      cKey := aLex[ 2 ]
+      aParams := aLex[ 3 ]
 
-   ::oParser := TSqlParser2():New( aTokens, ::aParams )
-   hQuery := ::oParser:Parse()
+      IF hb_HHasKey( s_hPlanCache, cKey )
+         hQuery := HbDeepClone( s_hPlanCache[ cKey ] )
+      ELSE
+         ::oParser := TSqlParser2():New( aTokens, aParams )
+         hQuery := ::oParser:Parse()
+         IF hQuery == NIL
+            RETURN { { "__error__" }, { { SQL_ERR_SYNTAX, "Failed to parse SQL", cSQL } } }
+         ENDIF
+         s_hPlanCache[ cKey ] := HbDeepClone( hQuery )
+      ENDIF
 
-   IF hQuery == NIL
-      RETURN { { "__error__" }, { { SQL_ERR_SYNTAX, "Failed to parse SQL", cSQL } } }
+      ::oExec := TSqlExecutor():New( hQuery, aParams )
+      ::oExec:cCacheKey := cKey
+   ELSE
+      /* Caller supplied explicit params — cache by raw SQL text. */
+      IF hb_HHasKey( s_hPlanCache, cSQL )
+         hQuery := HbDeepClone( s_hPlanCache[ cSQL ] )
+      ELSE
+         aTokens := SqlLexerTokenize( cSQL )
+         ::oParser := TSqlParser2():New( aTokens, ::aParams )
+         hQuery := ::oParser:Parse()
+         IF hQuery == NIL
+            RETURN { { "__error__" }, { { SQL_ERR_SYNTAX, "Failed to parse SQL", cSQL } } }
+         ENDIF
+         s_hPlanCache[ cSQL ] := HbDeepClone( hQuery )
+      ENDIF
+
+      ::oExec := TSqlExecutor():New( hQuery, ::aParams )
+      ::oExec:cCacheKey := cSQL
    ENDIF
 
-   ::oExec := TSqlExecutor():New( hQuery, ::aParams )
    ::oExec:bRowBlock := bBlock
    aResult := ::oExec:Run()