perf(gfql/polars): reuse the synthetic edge id as the stable edge order

The native polars chain executor attaches a synthetic edge id (`EID`) via
`with_row_index` when the graph has no edge binding, then — a few hundred lines later —
materializes a SECOND `with_row_index` column (`EORD`) over that same frame to restore
eager edge order for the fused combine. Both are 0..n-1 over the same frame in the same
order, because the second runs on the frame the first produced, so the second is pure
duplication of a graph-sized materialization.

Reuse EID as EORD when it was attached. Both columns were already dropped before
returning, so the single drop now covers it (guarded on `EID != EORD` for the case where
the graph brought its own edge binding and EORD is still a separate column).

Measured on a 3.18M-node / 14M-edge polars graph with polars-engine indexes, a seeded
typed pattern: 148.22 -> 135.43 ms (-8.6%). `with_row_index` was ~34 ms/query across the
eager calls before this.

Parity: 108 polars-path cases (9 traversal shapes x 12 random seeds, engine='polars' with
polars-engine indexes) hashed over column ORDER, dtypes, row count and full content --
0 differ, 0 raised. This is a new sweep: the existing 650-case differential runs
engine=auto, which resolves to pandas and never exercises this executor.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VARwnAqmvczhz5EmP7TYyZ

Author: lmeyerov

graphistry/compute/gfql/lazy/engine/polars/chain.py

@@ -928,8 +928,17 @@ def _plain_edge(op):
     from graphistry.compute.util import generate_safe_column_name
     from graphistry.compute.gfql.lazy import collect_all
     NORD = generate_safe_column_name("__gfql_norder__", g._nodes, prefix="__gfql_", suffix="__")
-    EORD = generate_safe_column_name("__gfql_eorder__", g._edges, prefix="__gfql_", suffix="__")
-    g_lz = _LazyShim(g._nodes.with_row_index(NORD).lazy(), g._edges.with_row_index(EORD).lazy(),
+    if added_edge_index:
+        # EID was attached above as `with_row_index` over THIS frame in THIS order, so it
+        # already IS the stable edge order. Materializing a second identical 0..n-1 column
+        # over a graph-sized edge frame is pure duplication (measured: `with_row_index`
+        # cost ~34ms/query across the eager calls on a 14M-edge graph). Reuse EID.
+        EORD = EID
+        edges_lz = g._edges.lazy()
+    else:
+        EORD = generate_safe_column_name("__gfql_eorder__", g._edges, prefix="__gfql_", suffix="__")
+        edges_lz = g._edges.with_row_index(EORD).lazy()
+    g_lz = _LazyShim(g._nodes.with_row_index(NORD).lazy(), edges_lz,
                      node_col, src, dst, g._edge)
     steps_lz = [(op, _LazyShim.step(p)) for op, p in steps]
     edge_steps_lz = [(op, _LazyShim.step(p)) for op, p in edge_steps]
@@ -947,7 +956,8 @@ def _plain_edge(op):
 
     final_nodes = final_nodes.sort(NORD).drop(NORD)
     final_edges = final_edges.sort(EORD).drop(EORD)
-    if added_edge_index:
+    if added_edge_index and EID != EORD:
+        # When EORD IS EID the drop above already removed it (same column, one drop).
         final_edges = final_edges.drop(EID)
     final_edges, final_nodes = collect_all([final_edges, final_nodes])
     final_edges = _restore_edge_dtypes(final_edges, src, dst, _endpoint_restore)