Expire a claim by the test's clock, not the database's (#166)

AnExpiredTokenDoesNotCompleteAClaim has been failing on main since some
time on 2026-08-31, with nothing changed to cause it. The date caused it.

ExpireAsync wrote `expires_at = now() - interval '1 day'` -- the database's
wall clock -- while the query it is setting up compares expires_at against
the injected clock. The two agreed only while real time stayed behind the
seeded clock plus the lifetime under test, and that window closed on its
own:

  Seed.Now                  2026-07-30 12:00Z
  + PendingLifetime + 1 day 2026-08-30 12:00Z   <- what the query compares
  now() - 1 day             2026-08-30 15:25Z   <- what the row said

Once the real calendar passed 2026-08-31 12:00Z the row stopped being in
the past as far as the query was concerned, so an expired token began
reading as Verified. The last green run on main was 2026-08-29.

The clock is injected precisely so that "later" is a fact rather than a
sleep; reaching for now() in the middle of that gave the test a dependency
on the day it happened to run. It now expires relative to the clock the
query uses, which is deterministic by construction.

Found while opening #165, whose CI this was failing. Unrelated to that
change -- it reproduces on unmodified main.

641 MUI.Catalog.Tests green.

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: HarryCordewener

tests/MUI.Catalog.Tests/Persistence/Claims/ClaimPostgresTests.cs

@@ -146,7 +146,7 @@ public async Task AnExpiredTokenDoesNotCompleteAClaim()
         var claim = await service.IssueAsync(game, user);
 
         clock.Advance(ClaimToken.PendingLifetime + TimeSpan.FromDays(1));
-        await ExpireAsync(db, claim.Id);
+        await ExpireAsync(db, claim.Id, clock.GetUtcNow());
 
         var verdict = await service.OfferBeaconAsync(game, claim.Token, ClaimChannel.Mssp);
 
@@ -442,13 +442,29 @@ private static async Task<bool> IsClaimedAsync(TestDatabase db, Guid game)
             "SELECT is_claimed FROM game WHERE id = @game", new { game });
     }
 
-    private static async Task ExpireAsync(TestDatabase db, Guid claim)
+    /// <summary>
+    /// Expires a claim as of the test's own clock rather than the database's.
+    /// </summary>
+    /// <remarks>
+    /// This used to write <c>now() - interval '1 day'</c>, which is the database's wall clock, while
+    /// the query it is setting up compares <c>expires_at</c> against the injected clock. The two
+    /// agreed only for as long as real time stayed behind the seeded clock plus the lifetime under
+    /// test — a window that closed on its own. <see cref="Seed.Now"/> is 2026-07-30 12:00Z, the test
+    /// advances 31 days to 2026-08-30 12:00Z, and once the real calendar reached 2026-08-31 12:00Z
+    /// the row written here stopped being in the past as far as the query was concerned, so an
+    /// expired token started reading as <c>Verified</c>. Nothing changed in the code; the date did.
+    /// <para>
+    /// The clock is passed in for the same reason it exists: so "later" is a fact rather than a
+    /// sleep, and so the test says the same thing on every day it is run.
+    /// </para>
+    /// </remarks>
+    private static async Task ExpireAsync(TestDatabase db, Guid claim, DateTimeOffset asOf)
     {
         await using var connection = await db.DataSource.OpenConnectionAsync();
 
         await connection.ExecuteAsync(
-            "UPDATE game_claim SET expires_at = now() - interval '1 day' WHERE id = @claim",
-            new { claim });
+            "UPDATE game_claim SET expires_at = @expiresAt WHERE id = @claim",
+            new { claim, expiresAt = asOf - TimeSpan.FromDays(1) });
     }
 
     /// <summary>A clock a test can push forward, so "later" is a fact rather than a sleep.</summary>