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).

apps/app_seeds/lib/services/social_service.dart

@@ -10,13 +10,26 @@ import 'package:commons_core/commons_core.dart';
 /// offline; nothing connects to a relay until [openSession] is called, so the
 /// app runs fully without network and the social layer only enriches.
 class SocialService {
-  SocialService({required this.identity, List<String> relays = const []})
-      : relays = List.unmodifiable(relays);
+  SocialService({
+    required this.identity,
+    this.account = 0,
+    this.rootSeedHex = '',
+    List<String> relays = const [],
+  }) : relays = List.unmodifiable(relays);
 
   /// The derived Nostr identity (secp256k1). Same key across reinstalls that
-  /// restore the same seed.
+  /// restore the same seed (for a given [account]).
   final NostrIdentity identity;
 
+  /// Which pseudonymous identity of the root seed this is (0 = the original).
+  /// Switching account changes the social identity while the backup stays the
+  /// single root seed. See [NostrKeyDerivation.deriveFromSeed].
+  final int account;
+
+  /// The root-seed hex, kept so the switcher can preview OTHER accounts'
+  /// identities without re-reading the keystore. Empty when unknown (tests).
+  final String rootSeedHex;
+
   /// Community relay URLs (may be empty — discovery/publishing degrade to
   /// nothing when offline or unconfigured).
   final List<String> relays;
@@ -25,15 +38,35 @@ class SocialService {
   String get npub => identity.npub;
   String get publicKeyHex => identity.publicKeyHex;
 
-  /// Derives the identity from the stored root-seed hex (32-byte, 64 chars).
+  /// Derives the identity from the stored root-seed hex (32-byte, 64 chars) for
+  /// the given [account] (0 = the original identity).
   static Future<SocialService> fromRootSeedHex(
     String rootSeedHex, {
+    int account = 0,
     List<String> relays = const [],
   }) async {
     final identity = await NostrKeyDerivation.deriveFromSeed(
       _hexToBytes(rootSeedHex),
+      account: account,
     );
-    return SocialService(identity: identity, relays: relays);
+    return SocialService(
+      identity: identity,
+      account: account,
+      rootSeedHex: rootSeedHex,
+      relays: relays,
+    );
+  }
+
+  /// The `npub` for another [account] of the same root seed, so the switcher can
+  /// show identities before committing to one. Returns null if the seed is
+  /// unknown (e.g. in tests constructed without it).
+  Future<String?> npubForAccount(int account) async {
+    if (rootSeedHex.isEmpty) return null;
+    final id = await NostrKeyDerivation.deriveFromSeed(
+      _hexToBytes(rootSeedHex),
+      account: account,
+    );
+    return id.npub;
   }
 
   /// Opens a session against [relayUrls]: one fault-tolerant pool carrying all