feat(app,qqa): EA preview safety, TSP penalty method, spin arrows on topology

Summary
-------
* `app/_common.py` — stop building O(N^2) Plotly heatmaps in the
  problem preview. For coupling matrices above ~600 spins fall back to
  a sparse non-zero scatter (O(nnz) markers). The default
  Edwards-Anderson selection (`L=32, dim=3`, N=32 768) used to OOM the
  browser tab; it now renders a structural spy plot instead. Default EA
  lattice side dropped from 32 to 6 so the first interaction also
  converges in <1 s.
* `src/qqa/problems/extras.py` — TSP rewritten as a true penalty
  method following Lucas (2014). `BinaryRelaxation(shape_fn=...)` lifts
  the latent into `(B, N, N)`; `loss_fn` returns
  `tour + lambda_r * row_pen + lambda_c * col_pen` so the optimiser
  sees both permutation constraints as gradients (the previous
  `CategoricalRelaxation` formulation hid the row constraint inside
  the relaxation's softmax). `score_summary` runs Hungarian assignment
  on every replica's projected matrix, mutates `best_sol` to the
  cleaned permutation, and surfaces `extra.raw_feasible` /
  `extra.snapped` so the dashboard can distinguish optimiser-converged
  tours from post-hoc-snapped ones.
* `app/streamlit_app.py` — sidebar replaces the single
  `column_penalty` slider with `row_penalty` + `col_penalty`, plus an
  explanatory caption. Per-problem `size_default` / `size_max` updated
  to keep EA, TSP usable out-of-the-box.
* `app/_solution_viz.py` — spin-system renderers now place up / down
  triangle markers on the actual topology of the problem:
  - 1D Ising -> ring with periodic bonds
  - SK -> circle (no spatial structure) + complementary local-energy
    bar (positive = frustrated)
  - 2D EA -> lattice grid with bond ribbons
  - 3D EA -> side-by-side z-slices (capped at six)
  Title carries colour-coded up / down counts. The TSP renderer adds
  segment direction arrows, an optional pairwise-distance backdrop for
  small N, and a "raw permutation" / "Hungarian-snapped" badge.
* `tests/test_extra_problems.py` — three new TSP regression tests
  (BinaryRelaxation + two penalties; per-term decomposition; Hungarian
  snap always returns a valid permutation) and one EA preview test
  ensuring the sparse scatter fallback fires for `L=16, dim=3`.

ruff format && ruff check clean. pytest: 91 passed, 1 skipped.

Author: Yuma-Ichikawa

app/_common.py

@@ -946,7 +946,8 @@ def build_problem(cfg: dict) -> Any:
     if kind == "tsp":
         return qqa.TSP(
             N=size,
-            column_penalty=float(extra.get("column_penalty", 3.0)),
+            row_penalty=float(extra.get("row_penalty", 5.0)),
+            col_penalty=float(extra.get("col_penalty", 5.0)),
             seed=cfg["seed"],
             device=device,
         )
@@ -1001,14 +1002,71 @@ def _graph_preview(g: nx.Graph, title: str) -> None:
 
 
 def _coupling_preview(J: np.ndarray, title: str) -> None:
-    fig = go.Figure(data=go.Heatmap(z=J, colorscale="RdBu", zmid=0, colorbar={"title": "J_ij"}))
+    """Show the coupling matrix without melting the browser.
+
+    Plotly's ``Heatmap`` is dense — every cell becomes a SVG rect. For
+    ``N ≳ 1000`` the trace alone is hundreds of MB; for the default EA
+    setting (``L=32, dim=3 ⇒ N=32 768``) it instantly OOMs the tab.
+    Past ``N_show=256`` we fall back to a *sparse* spy plot of the
+    non-zero couplings (still ``O(nnz)`` markers, not ``O(N²)`` rects).
+    Spin glasses on a hyper-cubic lattice have ``≈ d·N`` non-zeros, so
+    this stays well-behaved even at 32k spins.
+    """
+    N = J.shape[0]
+    # 600^2 ≈ 360k cells — Plotly handles that comfortably; 1k^2 = 1M is
+    # already laggy. Anything bigger ⇒ fall back to a sparse view.
+    N_show = 600
+    if N_show >= N:
+        fig = go.Figure(data=go.Heatmap(z=J, colorscale="RdBu", zmid=0, colorbar={"title": "J_ij"}))
+        fig.update_layout(
+            title={"text": title, "x": 0.5, "font": {"color": "#f8fafc"}},
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
+            height=400,
+        )
+        st.plotly_chart(fig, width="stretch")
+        return
+
+    rows, cols = np.nonzero(J)
+    if rows.size == 0:
+        st.info(f"{title}: coupling matrix is all-zero (N={N}).")
+        return
+    vals = J[rows, cols]
+    vmax = float(np.abs(vals).max())
+    fig = go.Figure(
+        data=go.Scatter(
+            x=cols,
+            y=rows,
+            mode="markers",
+            marker={
+                "size": 4,
+                "color": vals,
+                "colorscale": "RdBu",
+                "cmin": -vmax,
+                "cmax": vmax,
+                "colorbar": {"title": "J_ij", "thickness": 12},
+                "line": {"width": 0},
+            },
+            hovertemplate="i=%{y}, j=%{x}<br>J=%{marker.color:.3f}<extra></extra>",
+        )
+    )
     fig.update_layout(
-        title={"text": title, "x": 0.5, "font": {"color": "#f8fafc"}},
+        title={
+            "text": f"{title} — sparse view ({rows.size} non-zero entries)",
+            "x": 0.5,
+            "font": {"color": "#f8fafc"},
+        },
         paper_bgcolor="rgba(0,0,0,0)",
         plot_bgcolor="rgba(0,0,0,0)",
-        height=400,
+        height=440,
+        xaxis={"title": "j", "scaleanchor": "y", "scaleratio": 1, "autorange": True},
+        yaxis={"title": "i", "autorange": "reversed"},
     )
     st.plotly_chart(fig, width="stretch")
+    st.caption(
+        f"Showing {rows.size} non-zero couplings out of {N * N:,} matrix entries. "
+        "A dense heatmap at this size would crash the browser."
+    )
 
 
 def preview_problem(problem: Any, cfg: dict) -> None: