feat: un document en store public sert son ReadCap, une référence nue suffit

Le modèle amont est explicite dans `PublicRepoLinkV0` : le lien ne porte AUCUN
`read_cap`, et son commentaire dit pourquoi — *"The latest ReadCap of the branch
will be downloaded from the outerOverlay, if the peer brokers listed below allow
it […] the public site are served differently by brokers"*
(engine/net/src/types.rs:5098). La clé n'est pas remise par un émetteur : elle est
donnée par le réseau à qui la demande, parce que le broker a épinglé l'overlay
externe (`expose_outer`).

La bibliothèque refusait jusqu'ici la forme sans cap quel que soit le store. Sûr
dans le bon sens, mais une application ne pouvait pas exprimer « fais circuler, la
référence suffit » — le seul acte que le modèle rend gratuit — et son unique
contournement était de distribuer la clé, ce qui détruit la confidentialité
composable.

`emulated-verifier/public-store.ts` émule le mécanisme SANS toucher à la garde. La
possession reste l'unique critère : un document public est lisible non par exception
mais parce que son cap est *obtenable*. Chaque porte de lecture demande d'abord
(`readUnion`, `docs.sparqlQuery`, `ensureRepoOpen`, `documentInboxAddress`), puis le
chemin ordinaire s'applique.

Lire n'est pas écrire. Ce que le store sert est un droit de LECTURE :
`learnFromPublicStore` le classe à part et `assertMayWrite` refuse l'écriture
dessus. Sans cela une référence nue achetait une écriture, ce qu'aucun store amont
n'accorde.

Autres conséquences :

- `recordInPublicStore` (marquer + frapper) devient `markInPublicStore` (marquer).
  Frapper un second cap à côté de celui qu'on vient de télécharger donnerait deux
  clés différentes le jour où la constante devient un secret.
- `hasCap` quitte la porte polyfill : il se lisait « ai-je le droit de lire ceci ? »
  et un document public y répondait `false` jusqu'à ce qu'on demande son cap. Aucun
  appelant hors des tests.
- Les tests cross-user ne font plus traverser de cap par une variable JS : Bob
  n'obtient que la référence nue, comme une vraie application.

Écarts documentés plutôt que masqués : le pari sur un modèle DÉCLARÉ (`expose_outer`
est câblé à `false` côté client et `ExtTopicSyncReq` est `unimplemented!()`), la
découverte limitée à ce qu'on sait déjà nommer, `useShape` qui n'a pas d'await à
dépenser, et l'absence de `locator`.

179 tests unitaires, e2e 42/42 contre le broker en ligne.

docs/migration-guide.md

@@ -27,11 +27,12 @@ this step swaps the *emulated* key for the real one, not the model:
   `r:{base64url(serde_bare(ObjectRef))}`. It is **one function** (`mintCap`), because
   every path now READS a stored cap instead of recomputing one. `hasReadCap` /
   `targetOf` stay meaningful: the `r:` discriminant is upstream grammar, not ours.
-- `shareCap(cap, toInbox)` becomes the native sealed delivery (whatever the SDK ends up naming it — see the note below
+- `inbox.share(doc, toUser)` becomes the native sealed delivery (whatever the SDK ends up naming it — see the note below
   and `ContactDetails.read_cap`), and `inbox.read`'s inline absorption becomes the
   recipient's own verifier applying queued messages. **The consumer's call does not
   change.**
-- `publishRepoLink` becomes `RepoLinkV0`.
+- `caps.markInPublicStore` and the whole of `emulated-verifier/public-store.ts` disappear: which store a document sits in stops being a fact we record, and serving a public store's repos becomes the broker's job (`expose_outer`, the ReadCap downloaded from the outer overlay — `PublicRepoLinkV0`, `engine/net/src/types.rs:5098`). Nothing an application calls changes: it circulates bare references now, and will still.
+- `assertMayWrite` goes with it — refusing a write on a cap the public store served is a stand-in for the write cap this emulation does not have.
 - The read filter (`emulated-verifier/read-filter.ts`) and the possession gate in
   `read-model.readUnion` are then dead code — the broker only delivers documents
   whose cap the wallet holds. Remove them.
@@ -103,7 +104,7 @@ P1a broke the consumer once, deliberately and early, so that migration would not
 The old surface was an ACL held in memory, which forced the consumer to re-declare
 every grant on every session (`declareConnections`). That call **disappears**: with
 delivered caps the grant moves to the moment a connection is *accepted* — one
-`shareCap(capFor(doc), theirInbox)` per document shared — and it persists, because
+`inbox.share(doc, toUser)` per document shared — and it persists, because
 the delivery lives in the recipient's inbox rather than in a map that empties at
 reload. There is no analogue of `protectedDocsOf` + the re-derivation loop.