feat(data,engine): persist replay share URL alongside the replay

The v0.18.0 share-link affordance lived in an in-memory
LastSharedReplayUrl resource that was wiped on quit; the player had
to re-open Stats and re-share within the same session of the win.
The Stats overlay's Prev/Next selector also surfaced older replays
that had no share link at all even when those wins had been
uploaded successfully.

This bundles the URL with the replay it belongs to:

- Replay (solitaire_data) gains share_url: Option<String> with
  #[serde(default)]. No REPLAY_SCHEMA_VERSION bump — older
  replays.json files load unchanged with share_url == None on
  every entry. Replay::new() defaults the field to None.
- poll_replay_upload_result (sync_plugin) writes the resolved URL
  into ReplayHistoryResource::0.replays[0].share_url and persists
  the updated history via save_replay_history_to. The
  cancel-on-replace contract in push_replay_on_win guarantees
  replays[0] is the win whose URL the task is carrying — at most
  one upload is ever in flight, and it's always the most recent
  win.
- handle_copy_share_link_button (stats_plugin) reads from
  history.0.replays[selected.0].share_url instead of
  LastSharedReplayUrl, so the Prev/Next selector's currently-
  displayed replay drives the clipboard contents. Each historical
  win keeps its own URL.
- LastSharedReplayUrl resource removed entirely — its only role
  was bridging the upload-poll system to the Copy button, and
  that channel is now the share_url field on the replay record.

Tests:

- solitaire_data: replay_loads_when_share_url_field_is_absent
  pins backwards-compat — a pre-v0.19.0 Replay JSON without the
  field deserialises with share_url == None.
- solitaire_engine sync_plugin: upload_result_writes_share_url_into_replay_and_persists
  drives a pre-resolved AsyncComputeTaskPool task into
  PendingReplayUpload, pumps update() until the poll system
  resolves it, and asserts both the in-memory replays[0]
  carries the URL and a fresh load_replay_history_from(path)
  picks it up.

Workspace: 1170 passing tests / 0 failing, was 1168 (+2 net).
cargo clippy --workspace --all-targets -- -D warnings clean.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

solitaire_data/src/replay.rs

@@ -138,6 +138,15 @@ pub struct Replay {
     /// Ordered move list. Each entry is what the player did, replayable
     /// against a fresh `GameState` constructed from the seed.
     pub moves: Vec<ReplayMove>,
+    /// Public share URL for this replay on the active sync backend, set
+    /// by `sync_plugin::poll_replay_upload_result` when the upload
+    /// task resolves. `None` when the player won on a local-only
+    /// backend, the upload failed, or the replay pre-dates v0.19.0
+    /// share-link persistence. `#[serde(default)]` keeps older
+    /// `replays.json` files loadable without bumping
+    /// [`REPLAY_SCHEMA_VERSION`].
+    #[serde(default)]
+    pub share_url: Option<String>,
 }
 
 impl Replay {
@@ -162,6 +171,7 @@ impl Replay {
             final_score,
             recorded_at,
             moves,
+            share_url: None,
         }
     }
 }
@@ -481,6 +491,34 @@ mod tests {
         let _ = fs::remove_file(&path);
     }
 
+    /// Backwards-compat: a `Replay` record persisted before v0.19.0
+    /// share-link persistence carries no `share_url` field on disk.
+    /// `#[serde(default)]` must let it deserialise cleanly with
+    /// `share_url == None`, so existing players don't see their
+    /// rolling history wiped on the v0.19.0 update.
+    #[test]
+    fn replay_loads_when_share_url_field_is_absent() {
+        let pre_v019_json = format!(
+            r#"{{
+                "schema_version": {schema},
+                "seed": 1,
+                "draw_mode": "DrawOne",
+                "mode": "Classic",
+                "time_seconds": 60,
+                "final_score": 100,
+                "recorded_at": "2025-01-01",
+                "moves": []
+            }}"#,
+            schema = REPLAY_SCHEMA_VERSION,
+        );
+        let parsed: Replay = serde_json::from_str(&pre_v019_json)
+            .expect("pre-v0.19.0 replay JSON must still deserialise");
+        assert!(
+            parsed.share_url.is_none(),
+            "missing share_url field must default to None",
+        );
+    }
+
     /// Atomic-write contract — `.tmp` must not be left behind after
     /// `save_latest_replay_to` returns. Mirrors the same check that
     /// guards `save_game_state_to` in `storage.rs`.