test(stack-encrypt): say #1363 corrected the probe comment, and give assertions messages

After the merge of #1363, json_tree_subtree's comment says the server
"can pick it out"; mod.rs and the doc comment of
a_read_gives_away_its_bound_and_its_probes still quoted the old claim as
standing. Both now say it was corrected. The test's assert_eq! calls
gain the messages the rust-testing convention asks for, and mod.rs names
the two harness tests that show features no mutant can reach do fire.

Claude-Session: https://claude.ai/code/session_01N7bCqa3ZVJMcEE99RzVqEu

Author: coderdan

packages/stack-encrypt/tests/json_leakage/calibration.rs

@@ -419,9 +419,9 @@ mod the_harness {
     /// so `N = 64`, at two), the probe is the last token at its level and
     /// finds the element where the path's other tokens find the leaf below
     /// it, and which tokens find a node says which elements hold the rest of
-    /// the path. `json_tree_subtree`'s comment that "the server cannot tell
-    /// a probe from any other token" is true of a token's bytes and of
-    /// nothing else.
+    /// the path. `json_tree_subtree`'s comment once said "the server
+    /// cannot tell a probe from any other token", which is true of a token's
+    /// bytes and of nothing else; #1363 corrected it.
     #[test]
     fn a_read_gives_away_its_bound_and_its_probes() {
         let runtime = runtime();
@@ -444,23 +444,36 @@ mod the_harness {
             ],
         };
         let observed = real_world(&runtime, &cipher, &world);
-        assert_eq!(distinguishers::token_counts(&observed), [65, 4161]);
+        assert_eq!(
+            distinguishers::token_counts(&observed),
+            [65, 4161],
+            "one wildcard level sends N + 1 tokens, two send N² + N + 1"
+        );
         // 4,161 is also one level at a bound of 4,160; which tokens find a
         // node (the 65th finds `$.items[0].tags[64]`'s absence, not an
         // item) is what tells the reading apart.
         assert_eq!(
             distinguishers::bound_recovery(&observed),
-            [vec![(1, 64)], vec![(1, 4160), (2, 64)]]
+            [vec![(1, 64)], vec![(1, 4160), (2, 64)]],
+            "the count alone gives the bound"
         );
         let price = &distinguishers::wildcard_positions(&observed)[0];
         let price = price.as_ref().expect("a wildcard read");
         // No items; three, the second without a price; seventy, the
         // second without a price, longer than the bound.
-        assert_eq!(price[0], (vec![], false, None));
-        assert_eq!(price[1], (vec![0, 2], false, None));
+        assert_eq!(price[0], (vec![], false, None), "no items, no hits");
+        assert_eq!(
+            price[1],
+            (vec![0, 2], false, None),
+            "three items, the second without a price"
+        );
         let mut most: Vec<usize> = (0..64).collect();
         most.retain(|&i| i != 1);
-        assert_eq!(price[2], (most, true, Some(true)));
+        assert_eq!(
+            price[2],
+            (most, true, Some(true)),
+            "seventy items: the probe finds the element, under another selector"
+        );
     }
 
     /// `distinguishers::cross_kind_equalities` can fire: it is empty on the

packages/stack-encrypt/tests/json_leakage/mod.rs

@@ -92,7 +92,10 @@
 //!   on a column whose rows vary, which is the page's claim that the stored
 //!   order reveals each row's shape; and on the real scheme a wildcard
 //!   read's token list gives its bound and its probes away
-//!   (`a_read_gives_away_its_bound_and_its_probes`).
+//!   (`a_read_gives_away_its_bound_and_its_probes`). Two features no mutant
+//!   can reach are shown to fire: `cross_kind_equalities` on a world whose
+//!   token is a stored selector, and `token_derivability` on a read of a
+//!   position past every row's array.
 //!
 //! # What the profile found
 //!
@@ -115,13 +118,13 @@
 //! Against the SQL's own comment, not the page:
 //!
 //! 2. **A probe is told from the other tokens.** `json_tree_subtree`'s
-//!    comment says "the server cannot tell a probe from any other token".
+//!    comment said "the server cannot tell a probe from any other token".
 //!    It cannot from the token's bytes, but the probe is the last token at
 //!    its level, the count gives the bound away (65 tokens is one level at
 //!    `N = 64` and nothing else), and a probe that finds something finds
 //!    the element, whose selector differs from the leaf the path's other
-//!    tokens find. `a_read_gives_away_its_bound_and_its_probes`. The leakage
-//!    page does not repeat the claim; the comment is left to #1363.
+//!    tokens find. `a_read_gives_away_its_bound_and_its_probes`. #1363
+//!    corrected the comment, which now says the server "can pick it out".
 //!
 //! The three findings against the page as it stood before #1363 (an
 //! ordering term's length, equal values at two ordered paths, UTF-8 byte