fix(vba): conditional-compilation evaluator - Win32/Win16, True=-1, #Const support (closes #51)

[ardelperal]

Closes #51.

What

Three concrete gaps in preprocessConditionalCompilation
(src/extraction/vba-preprocess.ts) silently dropped ACTIVE
code in production Dysflow .bas/.cls files. The conservative
fallback was the right SAFETY primitive but the wrong DEFAULT —
true conditions were silently blanking because the whitelist
rejected too much.

Why

The current evaluator had:

• Win32 / Win16 unmapped — #If Win32 Then blanks its ACTIVE branch.
• - not in the whitelist — #If Win64 = -1 Then (VBA's natural
  comparison against VBA True = -1) blanks despite being True.
• No #Const support — #Const MODO_DEBUG = True followed by
  #If MODO_DEBUG Then blanks the user's own TRUE branch (the
  identifier #Const MODO_DEBUG isn't in the whitelist).

In a real Dysflow-managed Access codebase, every production
.bas/.cls file that uses these idioms loses its conditionally
active code to the inactive branch. This PR changes the
default from "unknown == inactive" (blanks everything) to
"intentionally FALSE values (Win16, False, etc.) blank; the rest
ACTIVE", with TRUE keyword semantics (True = -1) preserved per
the VBA spec.

Diff

File	Lines
src/extraction/vba-preprocess.ts	+153 / −16
__tests__/extraction-vba-preprocess.test.ts	+218
Total	+371 / −16

Inside the 400-line review budget.

Design

Surface fixes + light integer substitution (chosen over full bitwise arithmetic)

• true → -1, false → 0 substitution via regex — one pass
  per expression. Preserves correctness for the supported
  expression surface (truthy, =, <>, And, Or, Not):
  VBA's "any non-zero is True" matches JS truthy semantics.
• The simplification is documented inline (JSDoc on
  preprocessConditionalCompilation) so the next maintainer
  can promote to bitwise arithmetic when a future task needs to
  distinguish #If X = 1 from #If X = -1 on a True const.
• Full bitwise arithmetic (replace &&/||/! with integer ops
  on -1/0) is intentionally deferred — the surface fixes
  suffice for the current Dysflow expression set and keep the
  code surface small.

Pipeline restructure

The eval pipeline now lives in normalizeConditionalExpression,
shared between the #If/#ElseIf branch and the new #Const RHS
evaluator. Both call sites get the same conservative-false
behavior on whitelist failure:

1. #Const lookup (substitutes table entries via
   escapeRegExp-safe regex per name).
2. Hardcoded constant substitutions:
   VBA7/Win64/Win32 → true, Win16/Mac → false.
3. Operator rewrites: <> → !==, = → ===, And → &&,
   Or → ||, Not → !.
4. true/false → -1/0 (line 343–344).
5. Whitelist check (^(-?\d+|...|...)+$).
6. Function(…) eval with try/catch.

#Const handling

A new CONST_DIRECTIVE = /^\s*#Const\s+NAME = EXPR$/i regex; the
directive loop builds a per-call constTable: Map<string, string>
in a first pass that runs BEFORE the existing #If/#ElseIf/
#Else/#End If loop. #Const lines are blanked (parity
preserved), same convention as other directives.

Recursion is free: #Const X = Y (where Y was defined earlier)
works because the constTable is grown before evaluation. Self-
references are impossible because the entry is added AFTER its
RHS evaluates.

#Const NAME = True is equivalent to #Const NAME = -1 in
subsequent #If comparisons — the RHS evaluator returns the
numeric literal string for the boolean value.

Test coverage

11 atoms in __tests__/extraction-vba-preprocess.test.ts (new
describe "Issue #51: Win32/Win16 + True=-1 + #Const support" —
8 acceptance-criteria atoms plus 3 defensive guards):

1. #If Win32 Then / Debug.Print "x" / #End If → preserves
   Debug.Print "x" on the same line number (parity).
2. #If Win16 Then / Debug.Print "x" / #End If → blanks
   Debug.Print "x".
3. #Const MODO_DEBUG = True / #If MODO_DEBUG Then / Debug.Print "x" / #End If → preserves the branch.
4. #Const MODO_DEBUG = False / #If MODO_DEBUG Then / x / #Else / y / #End If → blanks x, preserves y.
5. #Const X = 1 / #If X = 1 Then / x / #End If → preserves.
6. #If Win64 = -1 Then / x / #End If → preserves.
7. #Const X = True / #If X = False Then / x / #End If → blanks.
8. Negative regression: unknown identifier still evaluates false.

• 3 defensive parity guards covering the #Const line itself,
  string-literal RHS rejection, and a multi-#Const chain.
• Existing 49 atoms stay green WITHOUT modification (covered by
  the full-VBA-suite run).

Validation

• pnpm exec vitest run __tests__/extraction-vba-preprocess.test.ts -t "Issue #51" → 11 passed
• Full VBA suite (7 files): 318 passed — zero regressions.
• pnpm run build → tsc clean, no TS errors.

Real-fixture validation

__tests__/extraction-vba-realfixtures.test.ts (15/15) green,
confirming no Dysflow source node-count regression. Per the
issue spec, any real Dysflow delta would be newly-active branches
(Win32/Win16 that were incorrectly suppressed becoming
active, plus #Const-gated code reaching the sweeps for the
first time) — exactly the intended fix.

Out of scope (intentional, deferred per spec)

• Full bitwise integer arithmetic for #If (True And True) = -1
  vs = 1 — the simplification suffices for the current
  Dysflow expressions and can be promoted when needed.
• Multi-line #Const RHS continuations (VBA _ lines).
• #Const NAME = "string literal" — VBA forbids in CC; the
  evaluator returns null and the line is blanked (parity
  preserved, no entry in constTable).

Not done

n/a — issue complete in this PR.