The sidebar anchors closed cycles the way the canvas always has

A maker↔reviewer pair — forward edge one way, guarded back-edge the
other — has no node without an inbound edge, and the sidebar's row tree
walked only from no-inbound roots: the whole cycle vanished from the
list while both loops ran. The canvas never had the bug, because
LoopGraph.startAnchors already anchors each cycle-only component at its
first node.

The sidebar now consumes startAnchors instead of keeping its own weaker
definition of "root", so the two views can never again disagree about
which loops exist. The graph-level behaviour was already pinned by
aClosedCycleIsAnchoredAtItsFirstNodeRatherThanNotAtAll.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: scgopi

graphcode/Sources/Features/App/AppSidebarView+Rows.swift

@@ -178,12 +178,17 @@ extension AppSidebarView {
     }
   }
 
-  /// This project's top-level rows — nodes nothing points at — in the human's
-  /// arrangement (`sidebarNodeOrder`), not the graph's insertion order.
+  /// This project's top-level rows, in the human's arrangement (`sidebarNodeOrder`).
+  ///
+  /// `startAnchors`, not a bare "nodes nothing points at" filter — the difference is a
+  /// bug this row tree had and the canvas never did: a closed cycle (a maker↔reviewer
+  /// pair, forward edge one way, guarded back-edge the other) has no node without an
+  /// inbound edge, so a walk from no-inbound roots alone dropped the whole cycle from
+  /// the sidebar — two loops running, neither listed. `startAnchors` anchors each
+  /// cycle-only component at its first node, and reusing it means the sidebar and the
+  /// canvas can never again disagree about which nodes exist.
   func orderedRootNodes(in project: ProjectFeature.State) -> [LoopNode] {
-    let roots = project.graph.nodes.filter { node in
-      !project.graph.edges.contains { $0.to == node.id }
-    }
+    let roots = project.graph.startAnchors.compactMap { project.graph.nodes[id: $0] }
     let order = project.sidebarNodeOrder
     return roots.sorted { a, b in
       (order.firstIndex(of: a.id) ?? .max) < (order.firstIndex(of: b.id) ?? .max)