fix(cypher): grammar-resolve where_predicates vs expr ambiguity (#1194)

[lmeyerov]

Summary

• resolves gfql/cypher: resolve Lark ambiguity between where_predicates and expr (grammar-level follow-up to #1125) #1194 by replacing regex/text-split lifting in generic_where_clause with grammar-driven reparsing of ambiguous WHERE clauses
• keeps primary Cypher parser on lalr (to avoid query-shape regressions), and adds a targeted earley where_clause subparser for ambiguous label-predicate cases
• hardens binder label narrowing to an explicit all-or-nothing policy: only narrow when the full WHERE predicate set is label-only
• updates parser/binder tests for routing and conservative mixed-predicate behavior

Why this shape

• a full parser switch to earley fixed ambiguity but regressed clause attachment (for example WITH ... WHERE ...)
• targeted where_clause reparsing preserves existing global parse behavior while removing the regex fallback and still using grammar-level disambiguation

Validation

• PYTHONPATH=. uv run --no-project --with lark --with pytest python -m pytest graphistry/tests/compute/gfql/cypher/test_parser.py -q
• PYTHONPATH=. uv run --no-project --with lark --with pytest python -m pytest graphistry/tests/compute/gfql/cypher/test_binder.py -q
• PYTHONPATH=. uv run --no-project --with lark --with pytest python -m pytest graphistry/tests/compute/gfql/cypher/test_lowering.py -q
• PYTHONPATH=. uv run --no-project --with ruff ruff check graphistry/compute/gfql/cypher/parser.py graphistry/compute/gfql/frontends/cypher/binder.py graphistry/tests/compute/gfql/cypher/test_parser.py graphistry/tests/compute/gfql/cypher/test_binder.py

[lmeyerov]

Review rerun (wave 3/4 equivalent) found no blocking issues, but one suggestion-level hardening item:

• In graphistry/compute/gfql/cypher/parser.py (generic_where_clause), the new sub-parse path currently uses a broad except Exception: pass around _where_clause_parser().parse(...) + transformer.
• Suggest narrowing this to the expected parse/transform failures (for example LarkError and known parser/validation exceptions), so unrelated runtime defects do not get silently downgraded into generic raw-expression fallback.

Current implementation is functionally sound for #1194 scope; this is mainly a robustness/observability improvement for future maintenance.

[lmeyerov]

Closing in favor of #1209, which addresses #1194 via the cleaner approach now that #1200 slice 1 (#1202) has landed.

What changed since this PR was opened:

• feat(gfql/ir): expose Lark boolean-expression tree as WhereClause.expr_tree (#1200 slice 1/N) #1202 merged on master, exposing WhereClause.expr_tree — Lark's parsed boolean tree as a structural value. This was not available when this PR was started.
• feat(gfql/binder): walk expr_tree, emit one BoundPredicate per top-level AND (#1200 slice 2/N) #1207 merged on master, teaching the binder to walk expr_tree and emit one BoundPredicate per top-level AND conjunct.

Why this PR is superseded:

• This PR replaces split_top_level_and + regex inside generic_where_clause with a secondary Earley parser instance (_where_clause_parser) that re-parses the WHERE clause text. Functionally correct, but it introduces a second Lark parser path alongside the primary LALR + the now-available structural expr_tree.
• After feat(gfql/ir): expose Lark boolean-expression tree as WhereClause.expr_tree (#1200 slice 1/N) #1202 + feat(gfql/binder): walk expr_tree, emit one BoundPredicate per top-level AND (#1200 slice 2/N) #1207 landed, the right path is to walk expr_tree directly — single source of truth, no second parser, no text re-splitting.

Replacement (#1209):

• Adds _match_bare_label_atom and _lift_label_only_and_spine helpers in cypher/parser.py.
• generic_where_clause walks BooleanExpr (AND-spine) or _ExpressionSlice.text (single atom) directly.
• Same I/O contract as this PR for every WHERE shape; verified across the parser/binder/conformance/slice-2 binder_expr_tree/lowering suites (1528 passed).
• Shrinks the duplicate-parsing surface flagged by gfql/ir: expose Lark and_op/or_op tree in WhereClause so passes walk structure instead of re-parsing text #1200 by retiring the regex+split path inside generic_where_clause.

The branch (m4-1194-lark-where-ambiguity) is left undeleted for reference.