feat(identity): switch social identity, all from the one backup

Adds pseudonymous, switchable social identities derived from the SAME root
seed via an account index (NostrKeyDerivation.deriveFromSeed(seed, account)).
HKDF is one-way so accounts are unlinkable to the Ğ1 key; account 0 is the
original identity, byte-for-byte unchanged (no rotation for current users),
and every account regenerates from the single seed — so switching adds
nothing to back up.

- SocialAccountStore: keystore-backed active account + max created.
- Per-identity stores (chats, profile, name cache) namespaced by account
  scope (account 0 = legacy keys, no migration) so identities never mix.
- switchSocialAccount() re-derives the identity, re-scopes the stores and
  restarts the inbox listener; RestartWidget rebuilds the tree to pick up
  the new social singletons. DB/inventory untouched.
- Profile 'Your identities' switcher: list, create, switch (with a note
  that messages/contacts are kept separate per identity). i18n en/es/pt/ast.

Tests: account-indexed derivation (legacy 0 unchanged, accounts distinct
yet deterministic, negatives rejected); SocialAccountStore; per-identity
store scope isolation. Resolves the flagged 'change identity' decision
(open-decisions §B).

Known: switching resets navigation to home (full tree rebuild).

packages/commons_core/test/identity/nostr_key_derivation_test.dart

@@ -49,6 +49,31 @@ void main() {
       expect(id.publicKeyHex, isNot(contains(seedHex)));
     });
 
+    test('account 0 is the legacy identity (byte-for-byte unchanged)',
+        () async {
+      final legacy = await NostrKeyDerivation.deriveFromSeed(seed);
+      final explicit = await NostrKeyDerivation.deriveFromSeed(seed, account: 0);
+      expect(explicit.privateKeyHex, legacy.privateKeyHex);
+      expect(explicit.publicKeyHex, legacy.publicKeyHex);
+    });
+
+    test('different accounts on one seed → unlinkable identities', () async {
+      final a0 = await NostrKeyDerivation.deriveFromSeed(seed, account: 0);
+      final a1 = await NostrKeyDerivation.deriveFromSeed(seed, account: 1);
+      final a2 = await NostrKeyDerivation.deriveFromSeed(seed, account: 2);
+      final keys = {a0.publicKeyHex, a1.publicKeyHex, a2.publicKeyHex};
+      expect(keys, hasLength(3)); // all distinct
+
+      // ...yet each account is itself deterministic (regenerates from the seed).
+      final a1again = await NostrKeyDerivation.deriveFromSeed(seed, account: 1);
+      expect(a1again.publicKeyHex, a1.publicKeyHex);
+    });
+
+    test('a negative account is rejected', () async {
+      expect(() => NostrKeyDerivation.deriveFromSeed(seed, account: -1),
+          throwsArgumentError);
+    });
+
     test('integrates with the real IdentityService root seed', () async {
       final rootSeed = IdentityService(random: Random(42)).generateRootSeed();
       expect(rootSeed.length, IdentityService.rootSeedLengthBytes);