feat(brahman-handshake+ente-zero): denylist + hot reload de policy de peers

Consolida PeerAllowlist + nueva denylist en un unico PeerPolicy con
allow + deny + hot reload via notify. Cubre los dos pendientes
documentados en el commit anterior y simplifica la API hacia un solo
punto de entrada.

API consolidada en brahman_handshake::peer_policy:
- PeerPolicy::open() — todo permitido (default).
- PeerPolicy::from_sets(allow, deny) — politica inline para tests.
- PeerPolicy::from_files(allow_path?, deny_path?) — carga ambos
  archivos opcionales.
- PeerPolicy::evaluate(peer) -> Decision { Admit | DeniedByDenylist
  | NotInAllowlist }. Decision lleva reason() para logging.
- PeerPolicy::reload() — recarga atomica desde paths asociados.
  Si un archivo falla, conserva la version anterior (un typo no
  baja la politica activa).
- PeerPolicy::spawn_watcher() -> JoinHandle — vigila los archivos
  via notify, debounce 250ms (coalesce de eventos por save), recarga
  atomica al detectar cambio.

Orden de evaluacion: deny-first.
1. peer in denylist -> DeniedByDenylist.
2. allowlist set y peer no in allowlist -> NotInAllowlist.
3. resto -> Admit.

Deny gana sobre allow (un peer en ambas es rechazado): la denylist
es la primitiva de "kill switch".

Watcher: vigila el directorio padre del archivo, no el archivo
mismo. Razon: editores tipicos hacen rename-and-replace que rompe
el watch del archivo pero no del dir. Filtra eventos por path al
procesar.

Wire en server: ServerConfig.allowlist -> ServerConfig.policy:
Option<PeerPolicy> (rename, scope local).

Wire en Arje (ente-zero): nueva env BRAHMAN_PEER_DENYLIST complementa
BRAHMAN_PEER_ALLOWLIST. setup_brahman_policy carga + spawn watcher
y devuelve (policy, JoinHandle) — el handle se conserva en main
para que el thread no aborte.

Activacion completa con todas las capas:
  BRAHMAN_LISTEN_MULTIADDR=/ip4/0.0.0.0/tcp/4101 \\
  BRAHMAN_PEER_ALLOWLIST=/etc/brahman/allow.txt \\
  BRAHMAN_PEER_DENYLIST=/etc/brahman/deny.txt \\
  ente-zero
# Editar deny.txt en caliente entra en efecto en ~250ms sin restart.

Tests: 10 unit en peer_policy (incluido watcher_reloads_on_file_change
con notify real) + 1 E2E nuevo libp2p_handshake_denylist_blocks_
listed_peer. 30 tests verdes en brahman-handshake. Sin regresion en
ente-zero.

Lo que cierra: politica completa (open/allow/deny/both), hot reload
sin restart, atomicidad de la recarga, resiliencia ante typos.

Pendientes futuros: aplicar policy a nivel de swarm via
libp2p_allow_block_list::Behaviour (rechazar antes del Noise
handshake), rotacion de keypair sin perder peer_id.

CHANGELOG.md

@@ -6,6 +6,107 @@ ratio/diff ver `git show <sha>`.
 
 ## 2026-05-09
 
+### 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
+dos pendientes documentados en el commit anterior y simplifica la
+API hacia un sólo punto de entrada.
+
+API consolidada en `brahman_handshake::peer_policy`:
+- `PeerPolicy::open()` — todo permitido (default).
+- `PeerPolicy::from_sets(allow: Option<BTreeSet<PeerId>>, deny: BTreeSet<PeerId>)`
+  — política inline para tests.
+- `PeerPolicy::from_files(allow_path?, deny_path?)` — carga ambos
+  archivos opcionales.
+- `PeerPolicy::evaluate(peer) -> Decision` — `Admit |
+  DeniedByDenylist | NotInAllowlist`. Decision lleva su `reason()`
+  para logging consistente.
+- `PeerPolicy::reload()` — recarga atómica desde los paths
+  asociados. **Si un archivo falla, conserva la versión anterior**
+  (un typo no debe tirar al Init en modo inseguro).
+- `PeerPolicy::spawn_watcher() -> JoinHandle` — vigila los
+  archivos vía `notify`, debounce 250ms (coalesce de los varios
+  eventos típicos de un save), recarga atómica al detectar cambio.
+
+Orden de evaluación (deny-first):
+1. Si `peer ∈ denylist` → `DeniedByDenylist`.
+2. Si hay allowlist y `peer ∉ allowlist` → `NotInAllowlist`.
+3. Resto → `Admit`.
+
+Esto significa que **deny gana sobre allow**: un peer en ambas listas
+es rechazado. Diseño explícito para que la denylist sea la primitiva
+de "kill switch" — agregar un peer al deny lo banea inmediatamente
+sin importar dónde más esté listado.
+
+Watcher: vigila el **directorio padre** del archivo, no el archivo
+mismo. Razón: editores típicos hacen rename-and-replace (escriben
+a tmp y rename al destino), lo que rompe el watch del archivo pero
+no el del dir. Filtra eventos por path al procesar.
+
+Wire en server:
+- `ServerConfig.allowlist` → `ServerConfig.policy: Option<PeerPolicy>`
+  (breaking rename, scope local al monorepo). Gate en `do_handshake`
+  llama `policy.evaluate(&peer)` y usa `decision.reason()` para el
+  mensaje de error tipado.
+
+Wire en Arje (`ente-zero`):
+- Nueva env `BRAHMAN_PEER_DENYLIST` complementa
+  `BRAHMAN_PEER_ALLOWLIST`. Cualquiera (o ambas) activa la política.
+- `setup_brahman_policy()` carga + arranca watcher. Devuelve
+  `(policy, JoinHandle)`; el handle se guarda en main para que el
+  thread no se aborte.
+- Failure modes degradan a "modo abierto" (sin política) con log,
+  preservando la doctrina PID 1.
+
+Activación end-to-end con todas las capas activas:
+```sh
+BRAHMAN_LISTEN_MULTIADDR=/ip4/0.0.0.0/tcp/4101 \
+BRAHMAN_PEER_ALLOWLIST=/etc/brahman/allow.txt \
+BRAHMAN_PEER_DENYLIST=/etc/brahman/deny.txt \
+ente-zero
+# El operador puede editar deny.txt en caliente y la nueva regla
+# entra en efecto en ~250ms sin restart del Init.
+```
+
+Tests: 10 unit en `peer_policy::tests`:
+- `open_admits_anyone`, `allow_only_admits_listed`,
+  `deny_overrides_open`, `deny_overrides_allow` (deny-first
+  semantics).
+- `from_files_with_both_lists`, `from_files_only_deny`,
+  `invalid_file_rejected_at_load`.
+- `reload_picks_up_changes` — manualmente recarga y verifica.
+- `reload_failure_preserves_previous_state` — invariante de
+  seguridad: archivo roto NO baja la política activa.
+- `watcher_reloads_on_file_change` — E2E del watcher con notify
+  real: muta archivo, espera < debounce + margen, verifica que
+  la política refleja el cambio sin haber llamado reload manualmente.
+
+Plus 1 E2E nuevo en `network_libp2p.rs`:
+`libp2p_handshake_denylist_blocks_listed_peer` — A configura
+`policy = PeerPolicy::from_sets(None, [banned_peer])`. Cliente
+con keypair baneada es rechazado; cliente con keypair distinta
+pasa el handshake.
+
+30 tests verdes en brahman-handshake (16 unit + 7 handshake + 3
+discovery + 4 libp2p incluyendo allowlist + denylist E2E). Sin
+regresión en ente-zero.
+
+Lo que cierra esta entrega:
+- Política completa de admisión: open / allow-only / deny-only /
+  allow+deny.
+- Hot reload sin restart del Init — el operador puede banear/admitir
+  peers en caliente editando archivos.
+- Atomicidad: la recarga es del paquete `(allow, deny)` completo, no
+  de cada lista por separado. No hay momento donde una lista esté
+  vieja y la otra nueva.
+- Resiliencia: errores de parseo NO bajan la política activa.
+
+Pendientes futuros del changelog:
+- Aplicar la política a nivel de swarm vía `libp2p_allow_block_list::
+  Behaviour` (rechazar ANTES del Noise handshake, ahorrar el
+  round-trip TCP+Noise por intento denegado).
+- Rotación de keypair sin perder peer_id (multi-key identity).
+
 ### feat(brahman-handshake+ente-zero): allowlist explícita de peers libp2p
 Capa de política sobre el trust criptográfico de Fase 3. Hasta ahora
 cualquier peer con keypair Ed25519 válida pasaba el handshake remoto;