docs(platform-wallet): correct the failed-load test's coverage claim

`failed_load_releases_persister_for_reconstruct` claimed the end-to-end
open -> failed load -> reopen path was "covered by the storage crate's own
round-trip coverage test". It is not: `platform-wallet-storage` contains no
reference to `PlatformWalletManager` outside README prose, and its
`sqlite_second_open_guard` asserts only the storage-side half — that dropping
the last `SqlitePersister` handle frees the path claim so a later open
succeeds. Nothing composes the two halves.

The doc now states what the test actually proves (a strong count back at 1 is
the necessary precondition for a clean re-open, not the re-open itself) and
why the composed path cannot be driven from this crate: the concrete
persister lives in `platform-wallet-storage`, which depends on this one. A
TODO marks the real gap on the side that can close it.

The stale justification for the omission is also dropped — it cited a
dev-dependency cycle, but the operative constraint is simply the direction of
the dependency.

<sub>🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent</sub>

Author: lklimek

packages/rs-platform-wallet/src/manager/load.rs

@@ -471,15 +471,16 @@ mod tests {
     /// doesn't hit `WalletStorageError::AlreadyOpen` masking the real error
     /// (issue #4133).
     ///
-    /// This is a **manager-side proxy**, not a full end-to-end proof: it asserts
-    /// the persister's strong count returns to 1 (the test's own probe) after a
-    /// failed load + teardown — a lingering adapter clone would keep it above 1
-    /// — which is the necessary precondition for a clean re-open. It does not
-    /// itself open a real `SqlitePersister`, fail, and re-open on the same path;
-    /// the platform-wallet ⇄ platform-wallet-storage dev-dependency cycle
-    /// precludes using the concrete persister here. That end-to-end
-    /// open → fail → reopen is covered by the storage crate's own round-trip
-    /// coverage test.
+    /// This is a **manager-side proxy**, not an end-to-end proof: a strong count
+    /// back at 1 (the test's own probe) after a failed load + teardown is the
+    /// necessary precondition for a clean re-open, not the re-open itself. The
+    /// concrete `SqlitePersister` lives in `platform-wallet-storage`, which
+    /// depends on this crate, so only that side can drive the composed path —
+    /// and its `sqlite_second_open_guard` covers just the other half (dropping
+    /// the last handle frees the path claim), never building a
+    /// `PlatformWalletManager`.
+    // TODO: cover the composed open -> failed load -> reopen from
+    // platform-wallet-storage; neither side asserts it today.
     // Multi-thread: dropping the manager runs upstream's `Drop`, whose
     // `ThreadRegistry::shutdown()` asserts a multi-thread runtime.
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]