feat(brahman-handshake): multi-key identity — rotacion de session sin perder peer_id logico

Cierra el ultimo pendiente del plan de red P2P. Hasta ahora, rotar
la keypair libp2p de un nodo cambiaba su peer_id, lo que invalidaba
todas las allowlists/denylists remotas que lo referenciaban.
Imposible rotar sin coordinar con todos los pares.

Solucion: separar identity master (Ed25519 persistente forever,
identifica al nodo como entidad logica) de session libp2p (Ed25519
efimera, rotable). El master firma certs de session con expiracion.
La politica de admision se evalua contra el master_peer_id del cert
— el session peer_id puede cambiar libremente sin tocar allowlists.

API nueva en brahman_handshake::identity:
- Identity::from_keypair / master_peer_id / issue_session_cert.
- SessionCert::verify devuelve (master_peer_id, session_peer_id).
- SessionCert::verify_against_session(expected_session_pk) verify +
  exige que el cert vincule esa session pubkey (previene reuso de
  certs ajenos).
- CertError tipado: UnknownVersion, DecodeMaster, DecodeSession,
  InvalidSignature, Expired, SessionMismatch, Sign.
- DEFAULT_SESSION_TTL = 24h. SESSION_CERT_VERSION = 1 documenta
  esquema; bump al cambiar canonicalizacion.

Wire:
- Hello.identity_cert: Option<SessionCert> agregado (default None,
  back-compat).
- Client::connect_with_stream_signed_with_cert variante que adjunta
  cert.
- network::connect_libp2p_with_cert paralelo a connect_libp2p.

Server (do_handshake): nuevo paso ANTES del policy gate. Si el
Hello trae cert, verify_against_session(&hello.signature.public_key)
y el logical_peer = master_peer_id derivado. Sin cert (path Fase 3),
logical_peer = expected_peer (compat). Cert invalido -> Unauthorized
antes de evaluar policy.

Migracion gradual: clientes sin cert siguen funcionando contra
servers con policy basada en session peer_ids.

Tests: 8 unit en identity::tests (issue+verify, mismatch, expired,
tampered sig/expires_at, unknown version, rotated_session_with_same_
master_yields_same_master_peer_id — la propiedad fundamental).

E2E definitivo identity_cert_allows_session_rotation_without_policy_
change: A allowlist[master_peer]; B conecta con session1+cert ->
admitido; B rota a session2!=session1 con cert nuevo del MISMO
master -> admitido SIN tocar la allowlist; sanity: session sin cert
es rechazada.

40 tests verdes en brahman-handshake + brahman-net.

Wire en Arje queda como follow-up: ente-zero es server-only y no
necesita identity (su keypair libp2p ya es estable). La API esta
lista para cuando algun modulo haga conexiones salientes con cert.

crates/core/brahman-handshake/src/client.rs

@@ -11,6 +11,7 @@ use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::net::UnixStream;
 
 use crate::codec::{read_frame, write_frame};
+use crate::identity::SessionCert;
 use crate::messages::{Farewell, Frame, HandshakeError, Hello, HelloAck, MatchEvent, Ping, SessionId};
 use crate::signature::{sign_hello, SignatureError};
 
@@ -89,7 +90,7 @@ where
         card: Card,
         wit: Option<WitInterface>,
     ) -> Result<Self, ClientError> {
-        Self::connect_inner(stream, card, wit, None).await
+        Self::connect_inner(stream, card, wit, None, None).await
     }
 
     /// Igual que `connect_with_stream` pero firma el Hello con
@@ -103,7 +104,23 @@ where
         wit: Option<WitInterface>,
         keypair: &Keypair,
     ) -> Result<Self, ClientError> {
-        Self::connect_inner(stream, card, wit, Some(keypair)).await
+        Self::connect_inner(stream, card, wit, Some(keypair), None).await
+    }
+
+    /// Igual que `connect_with_stream_signed` pero además adjunta un
+    /// `SessionCert` que vincula la session keypair a una identity
+    /// master estable. El server, al recibir el cert, evalúa la
+    /// política de admisión contra el `master_peer_id` (no contra
+    /// el session peer_id) — permitiendo rotar la session sin perder
+    /// la identidad reconocida en allowlists remotas.
+    pub async fn connect_with_stream_signed_with_cert(
+        stream: S,
+        card: Card,
+        wit: Option<WitInterface>,
+        session_keypair: &Keypair,
+        identity_cert: SessionCert,
+    ) -> Result<Self, ClientError> {
+        Self::connect_inner(stream, card, wit, Some(session_keypair), Some(identity_cert)).await
     }
 
     async fn connect_inner(
@@ -111,6 +128,7 @@ where
         card: Card,
         wit: Option<WitInterface>,
         keypair: Option<&Keypair>,
+        identity_cert: Option<SessionCert>,
     ) -> Result<Self, ClientError> {
         card.validate()
             .map_err(|e| ClientError::InvalidCard(e.to_string()))?;
@@ -127,6 +145,7 @@ where
             card: wire_card,
             wit,
             signature,
+            identity_cert,
         };
         write_frame(&mut stream, &Frame::Hello(hello)).await?;