6.F.28: six paradoxes in a ring, and none of them seen

The fix for 6.F.22 asked whether a cycle had come back round to this order
before letting it take the two guesses. Necessary but not sufficient: it
looked only at the dependencies added since that order started.

6.F.28 is six convoy paradoxes arranged in a ring, each a tidy four-order
cycle in its own right. Every one of them satisfied that test, settled
itself locally against a caller's provisional answer, and wrote the result
down as final. The ring they were links in was never seen at all -- no
backup rule, no Szykman, and an answer that was locally consistent six times
over and globally wrong.

An order may now only settle a cycle when nothing anywhere in the dependency
list is still waiting further down the stack. If one of its own callers is
entangled, the answer is that caller's to settle, because their value is the
one everything here was computed against.

6.G.19 in the previous commit and this leaves one deviation of the hundred
and thirty-nine. 6.F.29 is 6.F.28 plus a single support that unwinds the
whole ring, which is what the document keeps the pair for. The half of the
ring furthest from that support comes out right and the half nearest it does
not: the resolver settles the first order it reaches while a second free
value elsewhere in the ring reads the same under both of its guesses, and
declares a determinacy it has not earned. Both halves are consistent on
their own. Together they are not.

src/game/adjudicate.ts

@@ -368,12 +368,21 @@ function resolveAll(
     /*
      * Am I the outermost order of this cycle?
      *
-     * Only if the cycle came back round to me at all, and only if none of
-     * its other members is still waiting further down the stack. Anything
-     * else reports what it has and lets the one below ask.
+     * Two conditions. The cycle has to have come back round to me at all --
+     * otherwise I am merely standing next to one. And nothing anywhere in
+     * the dependency list may still be waiting further down the stack: if
+     * one of my own callers is entangled in this, the answer is theirs to
+     * settle, because their value is the one everything here was computed
+     * against.
+     *
+     * The second test looks at the whole list rather than the part added
+     * since I started, and the difference is the whole of 6.F.28. Six
+     * paradoxes in a ring, each a neat four-order cycle of its own; each one
+     * settled itself locally against a caller's provisional answer and
+     * recorded it as final, and the ring they were links in was never seen.
      */
     const cycle = dep.slice(mark)
-    if (!cycle.includes(p) || cycle.some((q) => below.has(q))) {
+    if (!cycle.includes(p) || dep.some((q) => below.has(q))) {
       stack.pop()
       dep.push(p)
       result.set(p, first)