test(temporal): make always-true-filter recall comparison order-insensitive

The unfiltered-vs-filtered recall equivalence test compared ordered key
lists across two calls, but the first (unfiltered) call reinforces both
hits — legitimately changing the ranking inputs (retrieval_count,
last_accessed_unix_ms) before the second call — and the final ORDER BY
tie-break is id ASC over random UUIDs. Post-rebase onto schema-v8 main
this flaked roughly half the time (creation crossing a millisecond
boundary + unlucky UUID order). The invariant under test is membership,
not order: compare sorted key sets.

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

Author: tcconnally

src/tools.rs

@@ -3087,13 +3087,20 @@ mod tests {
         )
         .expect("filtered recall");
         let fv: Value = serde_json::from_str(&filtered).unwrap();
+        // Compare as SETS (sorted), not ordered lists: the first (unfiltered)
+        // recall reinforces both hits, which legitimately changes the ranking
+        // inputs (retrieval_count, last_accessed) before the second call, and
+        // the final `id ASC` tie-break is over random UUIDs — so cross-call
+        // ORDER is not a stable property. Membership is.
         let keys = |v: &Value| -> Vec<String> {
-            v["items"]
+            let mut k: Vec<String> = v["items"]
                 .as_array()
                 .unwrap()
                 .iter()
                 .map(|i| i["key"].as_str().unwrap().to_string())
-                .collect()
+                .collect();
+            k.sort();
+            k
         };
         assert_eq!(keys(&uv), keys(&fv), "always-true filter must not change the result set");