feat(brahman-net+handshake): swarm-level deny via libp2p block_list

Optimizacion de seguridad: la denylist ya no espera al handshake
brahman para rechazar — ahora se proyecta al block_list behaviour
del swarm libp2p. Conexiones desde peers baneados son rechazadas
ANTES del Noise handshake, ahorrando el round-trip TCP+Noise por
cada intento denegado.

brahman-net:
- Nuevo behaviour block_list: allow_block_list::Behaviour<BlockedPeers>
  añadido al BrahmanBehaviour derivado. Default vacio.
- Nuevos comandos BlockPeer / UnblockPeer en el enum interno.
- API publica: BrahmanNet::block_peer / unblock_peer. Idempotentes.
- Dep nueva: libp2p-allow-block-list 0.6 (sub-crate, no es feature
  de libp2p en 0.56).

brahman_handshake::peer_policy:
- PeerPolicy gana net: Arc<RwLock<Option<Arc<BrahmanNet>>>>. Default
  None preserva callers existentes.
- Nuevo attach_to_net(net): sync inicial (block_peer por cada en
  deny) + guarda net para diff-sync en cada reload.
- reload extendido: snapshot prev_deny ANTES de mutar inner. Tras
  mutar, sync_deny_to_swarm aplica block/unblock por cada
  added/removed.
- Atomicidad preservada: si parse falla, sync no ocurre y la
  version anterior persiste tanto en policy como en block_list.

ente-zero: tras setup_brahman_net + setup_brahman_policy, si AMBOS
estan presentes -> policy.attach_to_net(net.clone()) con log
informativo.

Tests: 1 nuevo E2E swarm_level_deny_blocks_before_noise. A configura
policy con deny + attach_to_net. Cliente baneado intenta connect_libp2p;
en lugar del Unauthorized del handshake, ahora falla con error de
transporte/stream o timeout — el dial nunca completa porque el swarm
rechaza la conexion.

5 tests verdes en network_libp2p.rs. 31 tests totales en brahman-
handshake + brahman-net.

Trade-offs documentados:
- Mas eficiente contra DoS (no consume CPU del Noise por peer baneado).
- Misma fuente de verdad: PeerPolicy. Swarm es cache derivado, sync
  via diff en cada reload, sin drift posible.
- El handshake-level gate sigue activo como segunda linea (defensa
  en profundidad si por bug/race un peer baneado pasa el block_list).

CHANGELOG.md

@@ -6,6 +6,74 @@ ratio/diff ver `git show <sha>`.
 
 ## 2026-05-09
 
+### feat(brahman-net+handshake): swarm-level deny — la denylist se proyecta al block_list de libp2p
+Optimización de seguridad: la denylist ya no espera al handshake
+brahman para rechazar — ahora se proyecta al `block_list` behaviour
+del swarm libp2p. Conexiones desde peers baneados son rechazadas
+**antes del Noise handshake**, ahorrando el round-trip TCP+Noise
+por cada intento denegado.
+
+Wire de bajo nivel (`brahman-net`):
+- Nuevo behaviour `block_list: allow_block_list::Behaviour<BlockedPeers>`
+  añadido al `BrahmanBehaviour` derivado. Vive junto a `stream`,
+  `kad`, `identify`. Default vacío al construir.
+- Nuevos comandos `BlockPeer(PeerId)` y `UnblockPeer(PeerId)` en el
+  enum interno + handlers que llaman
+  `swarm.behaviour_mut().block_list.{block_peer,unblock_peer}`.
+- API pública: `BrahmanNet::block_peer(peer)` y
+  `BrahmanNet::unblock_peer(peer)`. Idempotentes.
+- Dep nueva: `libp2p-allow-block-list = "0.6"` (sub-crate, no es
+  feature de `libp2p` en 0.56).
+
+Wire en la política (`brahman_handshake::peer_policy`):
+- `PeerPolicy` gana campo opcional `net: Arc<RwLock<Option<Arc<BrahmanNet>>>>`.
+  Default `None` para preservar callers existentes.
+- Nuevo método `attach_to_net(net: Arc<BrahmanNet>)`:
+  - Sincronización inicial: itera la deny actual y llama
+    `net.block_peer(p)` por cada uno.
+  - Guarda el net para diff-sync en cada `reload`.
+- `reload()` extendido: snapshot de `prev_deny` ANTES de mutar el
+  inner. Tras la mutación, llama `sync_deny_to_swarm(prev, new)`
+  que aplica `block_peer` por cada added y `unblock_peer` por cada
+  removed.
+- Atomicidad preservada: si un archivo falla al parsear, el sync
+  no ocurre y la versión anterior persiste tanto en la policy
+  como en el block_list del swarm.
+
+Wire en Arje (`ente-zero`):
+- Tras setup_brahman_net + setup_brahman_policy, si AMBOS están
+  presentes se llama `policy.attach_to_net(net.clone())` con un log
+  informativo. Sin policy o sin net, no hay attach (modo abierto
+  o solo gate-level deny).
+
+Tests: 1 nuevo E2E en `network_libp2p.rs`:
+`swarm_level_deny_blocks_before_noise`. A configura policy con
+deny de un peer + attach_to_net. Cliente baneado intenta
+`connect_libp2p`; en lugar del `HandshakeError::Unauthorized` que
+recibíamos antes (que requería completar Noise primero), ahora
+falla con error de transporte/stream (o timeout, según timing) —
+el dial nunca completa porque el swarm rechaza la conexión.
+
+5 tests verdes en `network_libp2p.rs` (roundtrip, mismatched signing,
+allowlist, denylist handshake-level, denylist swarm-level). 31 tests
+totales en brahman-handshake + brahman-net. Sin regresión en
+ente-zero.
+
+Trade-offs:
+- **Más eficiente** contra DoS: un atacante que prueba miles de
+  peer_ids no consume CPU del Noise handshake.
+- **Misma fuente de verdad**: la denylist sigue viviendo en
+  `PeerPolicy` (un solo archivo, hot-reloadable). El swarm es un
+  cache derivado que se actualiza vía diff. No hay drift posible —
+  cada reload re-sincroniza atómicamente.
+- **El handshake-level gate sigue activo** como segunda línea: si
+  por alguna razón un peer baneado pasa el block_list (race entre
+  reload y nueva conexión, o bug del crate), el handshake brahman
+  igual lo rechaza con `Unauthorized`. Defensa en profundidad.
+
+Pendientes futuros del changelog:
+- Rotación de keypair sin perder peer_id (multi-key identity).
+
 ### feat(brahman-handshake+ente-zero): denylist + hot reload de la política de peers
 Consolida `PeerAllowlist` + nueva `PeerDenylist` en un único
 `PeerPolicy` con allow + deny + hot reload vía `notify`. Cubre los