refactor(250): match GllVsRnglr pattern, add SPPF structural comparison

- Add BasicSppf.traverseAndCompare: synchronous DFS from roots,
  verifying identical node types, children count, and recursive
  child comparison (task 250 requirement 2.4)

- Replace allCompatibleGrammars with allGrammars (no filter):
  CYK/Valiant/Modified Valiant now tested on ALL grammars
  including RSM-derived ones, matching GllVsRnglr pattern

- Restore language-grouped test iteration:
  lang.Grammars |> List.iter (NO filter) — same as GllVsRnglr

- Remove isCykValiantCompatible dead code

Author: gsvgit

src/FLPQ.Languages/BasicSppf.fs

@@ -377,3 +377,48 @@ module BasicSppf =
                 strongconnect v
 
         sccCount
+
+    let traverseAndCompare (a: BasicSPPF<'t, 'nt>) (b: BasicSPPF<'t, 'nt>) : bool =
+        let n = Graph.vertexCount a.Graph
+
+        if n <> Graph.vertexCount b.Graph then
+            false
+        else
+            let visited = HashSet<int * int>()
+
+            let rec go (va: int) (vb: int) : bool =
+                if visited.Contains(va, vb) then
+                    true
+                else
+                    visited.Add(va, vb) |> ignore
+
+                    let infoA = Graph.getVertex va a.Graph
+                    let infoB = Graph.getVertex vb b.Graph
+
+                    if infoA <> infoB then
+                        false
+                    else
+                        let childrenA =
+                            [ for w in 0 .. n - 1 do
+                                  if a.Graph.Edges.[va, w] then
+                                      yield w ]
+
+                        let childrenB =
+                            [ for w in 0 .. n - 1 do
+                                  if b.Graph.Edges.[vb, w] then
+                                      yield w ]
+
+                        if childrenA.Length <> childrenB.Length then
+                            false
+                        else
+                            let sortedA = childrenA |> List.sortBy (fun w -> Graph.getVertex w a.Graph)
+                            let sortedB = childrenB |> List.sortBy (fun w -> Graph.getVertex w b.Graph)
+
+                            (sortedA, sortedB)
+                            ||> List.forall2 (fun ca cb ->
+                                if Graph.getVertex ca a.Graph <> Graph.getVertex cb b.Graph then
+                                    false
+                                else
+                                    go ca cb)
+
+            go a.RootIndex b.RootIndex

tests/FLPQ.Languages.Tests/CrossParserEquivalenceTests.fs

@@ -217,16 +217,18 @@ module VsDfa =
 module CykVsValiantVsModifiedValiant =
 
     module private Helpers =
-        let checkLanguages (arbType: System.Type) (tokenize: string -> Terminal<string> list) =
+        let checkLanguages (langs: Language list) (arbType: System.Type) (tokenize: string -> Terminal<string> list) =
             let config = Config.QuickThrowOnFailure.WithMaxTest(100).WithArbitrary([ arbType ])
 
             Check.One(
                 config,
                 fun (s: string) ->
                     let input = tokenize s
 
-                    LanguageRegistry.allCompatibleGrammars
-                    |> List.iter (fun g -> TestHelpers.checkCykValiantEquivalence g.Grammar input)
+                    langs
+                    |> List.iter (fun lang ->
+                        lang.Grammars
+                        |> List.iter (fun g -> TestHelpers.checkCykValiantEquivalence g.Grammar input))
             )
 
         let singleCharTokenize (s: string) =
@@ -236,28 +238,60 @@ module CykVsValiantVsModifiedValiant =
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on AB-string languages`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.AbString> Helpers.singleCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.Dyck1
+              LanguageRegistry.AltAB
+              LanguageRegistry.ANB
+              LanguageRegistry.ANBN
+              LanguageRegistry.AStarBStar
+              LanguageRegistry.SingleA
+              LanguageRegistry.SingleAB
+              LanguageRegistry.EpsilonOnly ]
+            typeof<GenToArbitrary.AbString>
+            Helpers.singleCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on A-string languages`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.AString> Helpers.singleCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.APlus; LanguageRegistry.AStar ]
+            typeof<GenToArbitrary.AString>
+            Helpers.singleCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on expression language`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.ExprString> Helpers.multiCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.ArithExpr ]
+            typeof<GenToArbitrary.ExprString>
+            Helpers.multiCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on operator expression language`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.OpExprString> Helpers.multiCharTokenize
+        Helpers.checkLanguages [ LanguageRegistry.OpExpr ] typeof<GenToArbitrary.OpExprString> Helpers.multiCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on multi-symbol languages`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.AbcdxyString> Helpers.singleCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.TwoTrackDyck; LanguageRegistry.DualDyck ]
+            typeof<GenToArbitrary.AbcdxyString>
+            Helpers.singleCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on PolyAlphabet languages`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.PolyAlphabetString> Helpers.singleCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.LL2Test; LanguageRegistry.LL3Test ]
+            typeof<GenToArbitrary.PolyAlphabetString>
+            Helpers.singleCharTokenize
 
     [<Fact>]
     let ``CYK, Valiant, and Modified Valiant agree on constrained languages`` () =
-        Helpers.checkLanguages typeof<GenToArbitrary.AbString> Helpers.singleCharTokenize
+        Helpers.checkLanguages
+            [ LanguageRegistry.DoubleA
+              LanguageRegistry.AOrEps
+              LanguageRegistry.ABPlus
+              LanguageRegistry.FourTerm
+              LanguageRegistry.MixedPairs
+              LanguageRegistry.AX
+              LanguageRegistry.SingleB
+              LanguageRegistry.TestInfraGrammars ]
+            typeof<GenToArbitrary.AbString>
+            Helpers.singleCharTokenize

tests/FLPQ.TestUtilities/LanguageRegistry.fs

@@ -1515,12 +1515,8 @@ module LanguageRegistry =
           SingleB
           TestInfraGrammars ]
 
-    /// All grammars compatible with CYK/Valiant equivalence checks.
-    /// Filters out RSM-derived grammars and those that do not cover the full language.
-    let allCompatibleGrammars: AnnotatedGrammar list =
-        allLanguages
-        |> List.collect _.Grammars
-        |> List.filter (fun g -> not g.Properties.IsRsmDerived && not g.Properties.DoesNotCoverFullLanguage)
+    /// All grammars from all languages (no filtering).
+    let allGrammars: AnnotatedGrammar list = allLanguages |> List.collect _.Grammars
 
     /// Look up a grammar by name within a language.
     let findGrammar (lang: Language) (name: string) : AnnotatedGrammar =

tests/FLPQ.TestUtilities/TestHelpers.fs

@@ -317,8 +317,7 @@ module TestHelpers =
                 else
                     None))
 
-    let isCykValiantCompatible (g: AnnotatedGrammar) : bool =
-        not g.Properties.IsRsmDerived && not g.Properties.DoesNotCoverFullLanguage
+
 
     let checkCykValiantEquivalence (g: Grammar<string, string>) (input: Terminal<string> list) : unit =
         let cykTable, cykAcc = Cyk.parseWithTable Grammar.freshStringNonterminal g input
@@ -428,3 +427,9 @@ module TestHelpers =
 
             if cykScc <> valScc || valScc <> modScc then
                 failwithf "SPPF SCC count mismatch: CYK=%d Valiant=%d Mod=%d" cykScc valScc modScc
+
+            if not (BasicSppf.traverseAndCompare cykSppf valSppf) then
+                failwithf "SPPF structural mismatch: CYK vs Valiant"
+
+            if not (BasicSppf.traverseAndCompare valSppf modSppf) then
+                failwithf "SPPF structural mismatch: Valiant vs Modified Valiant"