refactor: renommer client → sdk, et fusionner les deux portes en une

Deux mouvements de surface, aucun changement de comportement.

**`packages/client` → `packages/sdk`, `@ng-eventually/client` → `@ng-eventually/sdk`.**
« client » ne disait rien : ce paquet EST le SDK que l'application appelle, et c'est
tout ce qu'elle appelle. L'ancien nom reste comme mot-clé de recherche dans
`docs/source-layout-by-fate.md` et le tableau des paquets du README.

**Une seule entrée.** L'entrée `./polyfill` disparaît ; ses symboles applicatifs —
`configure`, `configureStoreRegistry`, `setCurrentUser`, `connectedUser` et leurs types
— vivent dans un bloc `POLYFILL-ERA` de `src/index.ts`.

Ce que la seconde porte portait mérite d'être nommé avant d'être retiré : *ce qu'on
importe de ce chemin est exactement ce qu'on supprimera à la migration*. Une seule
porte perd ce signal — rien à la ligne d'import ne distingue `configure`, qui part, de
`docs`, que le vrai SDK remplace sur place. Trois choses le portent désormais : le bloc
lui-même, l'inventaire d'exports de `docs/api-contract.md` (épinglé par
`test/vocabulary.test.ts`, donc il ne peut pas rancir en silence), et le contrôle de
vocabulaire sur les noms publiés.

**Six symboles quittent la surface au passage**, et la fusion est ce qui a rendu le
choix visible plutôt qu'hérité :

- `getConfig` / `getStoreRegistryDeps` — câblage interne, atteint par
  `shared-wallet/bootstrap` ;
- `resetConfig` / `resetStoreRegistry` / `resetCaps` — remises à zéro de test, atteintes
  par leur chemin interne, ce qui est leur raison d'être ;
- le `share` direct — `inbox.share` a toujours été la même fonction, et la publier deux
  fois brouillait la frontière qu'elle servait à marquer.

Corrections d'affirmations fausses trouvées en chemin : le contrat annonçait `isNuri` /
`hasReadCap` sur la porte SDK alors qu'ils ne sont plus exportés depuis le passage au
permissif en entrée (`NuriLike` validé à la porte) ; le README du paquet documentait
`capFor`, `shareCap`, `getCaps` et `publishRepoLink`, dont aucun n'existe ; et le README
de l'app d'exemple affirmait que la suite e2e la pilote, ce qui reste à faire.

179 tests unitaires, typecheck bibliothèque / exemple / harnais, e2e 42/42 contre le
broker en ligne — mesuré une fois après le renommage, une fois après la fusion.

packages/sdk/test/accounts.test.ts

@@ -0,0 +1,75 @@
+import { test, expect } from "bun:test";
+import {
+  IdentityStore,
+  browserIdentityStore,
+  ACCOUNT_STORAGE_KEY,
+  type VirtualUserStorage,
+} from "../src/shared-wallet/virtual-users";
+
+// In-memory fake of the Storage subset — keeps this framework/DOM-agnostic.
+function fakeStorage(): VirtualUserStorage & { map: Map<string, string> } {
+  const map = new Map<string, string>();
+  return {
+    map,
+    getItem: (k) => (map.has(k) ? (map.get(k) as string) : null),
+    setItem: (k, v) => void map.set(k, v),
+    removeItem: (k) => void map.delete(k),
+  };
+}
+
+test("IdentityStore: set persists a trimmed id, get reads it back", () => {
+  const s = fakeStorage();
+  const store = new IdentityStore(s);
+  expect(store.get()).toBeNull();
+
+  expect(store.set("  marie ")).toBe("marie"); // trimmed
+  expect(store.get()).toBe("marie");
+  expect(s.map.get(ACCOUNT_STORAGE_KEY)).toBe("marie");
+});
+
+test("IdentityStore: a blank id is ignored, keeps the previous value", () => {
+  const store = new IdentityStore(fakeStorage());
+  store.set("bob");
+  expect(store.set("   ")).toBe("bob");
+  expect(store.get()).toBe("bob");
+});
+
+test("IdentityStore: clear removes the id (no throw)", () => {
+  const store = new IdentityStore(fakeStorage());
+  store.set("bob");
+  store.clear();
+  expect(store.get()).toBeNull();
+});
+
+test("IdentityStore: null storage degrades to non-persisting (SSR-safe)", () => {
+  const store = new IdentityStore(null);
+  expect(store.get()).toBeNull();
+  expect(store.set("bob")).toBe("bob"); // returns the value, just doesn't persist
+  expect(store.get()).toBeNull();
+  store.clear(); // no throw
+});
+
+test("IdentityStore: swallows storage errors on read and write", () => {
+  const throwing: VirtualUserStorage = {
+    getItem: () => {
+      throw new Error("boom");
+    },
+    setItem: () => {
+      throw new Error("boom");
+    },
+    removeItem: () => {
+      throw new Error("boom");
+    },
+  };
+  const store = new IdentityStore(throwing);
+  expect(store.get()).toBeNull(); // read error swallowed → null
+  expect(() => store.set("bob")).not.toThrow();
+  expect(() => store.clear()).not.toThrow();
+});
+
+test("browserIdentityStore returns a working store (uses global localStorage if present)", () => {
+  const store = browserIdentityStore("ng-eventually.test.account");
+  expect(store).toBeInstanceOf(IdentityStore);
+  // Behaves regardless of environment: set returns the value.
+  expect(store.set("zoe")).toBe("zoe");
+});