feat(renaser): Fase 20 — Akasha Over Ether (grafo distribuido)

Tres mensajes y un EtherType propio bastan para extender el grafo de
objetos —direccionado por contenido, ya BLAKE3— a otras maquinas
renaser que escuchen en la misma red de capa-2. Sin TCP, sin IP,
sin DNS.

Crate nueva 'akasha/' (no_std compartido, gemela de 'formato',
excluida del workspace):

  - MensajeAkasha enum con SolicitarObjeto(id), ProveedorObjeto(id,
    payload), AnunciarRaiz(id).
  - Codec: postcard (mismo que ya usa el grafo en disco).
  - EtherType: 0x88B5. MAX_PAYLOAD_AKASHA = 1486 (MTU sin fragmentar).
  - Helpers componer_frame(src, dst, msg) y analizar_frame(bytes) que
    distinguen EtherType ajeno, frame truncado y payload basura.
  - 6 pruebas unitarias en verde.

Modulo nuevo 'kernel/src/akasha.rs' con tres oficios:

  1. Demuxer (drenar_y_demultiplexar): drena la cola RX del dispositivo
     virtio-net y demultiplexa: frames AoE con payload valido los
     procesa el respondedor; el resto va a una cola del userspace que
     'sys_net_recibir' ahora lee. Frames 0x88B5 con payload
     no-postcard (saludo de pregon) se cuentan y tambien viajan al
     userspace.

  2. Atencion de mensajes (procesar):
     - SolicitarObjeto(id): consulta almacen::recuperar; si tenemos el
       objeto, respondemos ProveedorObjeto unicast con objeto.serializar()
       y re-hashing de defensa en profundidad.
     - ProveedorObjeto(id, payload): verifica blake3(payload)==id antes
       de absorber con almacen::almacenar.
     - AnunciarRaiz(id): si ignoramos el nodo, le solicitamos al emisor.

  3. Faro periodico (difundir_raiz cada 5 s): broadcast del hash del
     manifiesto actual. Cadencia medida contra reloj::milisegundos(),
     no contra los awaits — el interprete wasmi de los apps degrada
     la cadencia de EsperaFrame::await a varios cientos de ms, asi
     que se mide contra el reloj monotono y los oficios per-fotograma
     se enganchan al tic del compositor (cuyo latido es fiable).

Contadores ResumenAkasha (rx/tx por variante, descartados, cola del
usuario) listos para un futuro indicador AoE en la barra de tareas.

Cambios complementarios:

  - sys_net_recibir lee de akasha::pop_usuario, no de
    drivers::red::recibir_en (que queda #[allow(dead_code)] como
    primitiva del driver para diagnostico).
  - tarea_red queda corta: envia un ARP al gateway y termina. El
    demuxer y el faro viven en el tic del compositor.

Verificacion:

  - 'cargo test -p akasha' → 6 pruebas en verde.
  - QEMU headless 60 s con -object filter-dump → 14 frames: 11
    AnunciarRaiz (Δ promedio 5.86 s sobre 5.00 s de target), 2 ARP
    y el pregon hello. Cada AnunciarRaiz lleva el hash del manifiesto
    '2f3deadfcc7dae25..' en 33 bytes postcard sobre 47 bytes de frame.
  - COM1 vuelca 'akasha :: ANUNCIO emitido :: raiz=2f3deadfcc7dae25..'
    en cada disparo.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

renaser/CHANGELOG.md

@@ -1222,3 +1222,89 @@ misma capacidad a los apps: tres capacidades nuevas (`sys_net_mac`,
 - Captura de pantalla: la ventana `pregon :: voz hacia la red` aparece
   teselada, su pestaña sale en la barra de tareas entre `bitacora` y
   `tonada`, y la consola anuncia `manifiesto :: 9 apps nacidas del grafo`.
+
+---
+
+## Fase 20 — Akasha Over Ether: el grafo distribuido — 2026-05-23
+
+La red dejo de ser un puro medio para mensajes ad-hoc y se vuelve el cable
+por donde el GRAFO de objetos se extiende a otras maquinas renaser. Tres
+mensajes bastan; `postcard` los serializa; el EtherType `0x88B5` los
+transporta; ningun byte de TCP, IP, DNS o cabecera transporte de los anos 80.
+
+### Añadido
+- **Crate `akasha/`** — nucleo `#![no_std]` compartido (gemela de `formato`),
+  excluida del workspace anfitrion. Define `MensajeAkasha` con tres
+  variantes —`SolicitarObjeto(id)`, `ProveedorObjeto(id, payload)`,
+  `AnunciarRaiz(id)`—, las helpers `componer_frame(src, dst, msg)` y
+  `analizar_frame(bytes) -> Result<(Mac, MensajeAkasha)>`, y las constantes
+  `ETHER_TYPE_AKASHA = 0x88B5`, `MAX_PAYLOAD_AKASHA = 1486`. Seis pruebas
+  unitarias cubren el ida-y-vuelta de cada variante, la distincion entre
+  EtherType ajeno, frame truncado y payload basura.
+- **Modulo `kernel/src/akasha.rs`** — el respondedor del nucleo. Tres oficios:
+  1. **Demuxer** (`drenar_y_demultiplexar`): drena la cola RX del dispositivo
+     virtio-net y demultiplexa: frames AoE con payload valido los procesa
+     `procesar`; el resto va a la cola del userspace.
+  2. **Atencion de mensajes** (`procesar`): `SolicitarObjeto` busca en
+     `almacen` y, si tiene el objeto, responde `ProveedorObjeto` unicast;
+     `ProveedorObjeto` verifica integridad (`blake3(payload) == id`) y
+     absorbe al grafo local con `almacen::almacenar`; `AnunciarRaiz` se
+     contabiliza y, si no tenemos el nodo, le solicita al emisor.
+  3. **Faro** (`difundir_raiz` cada 5 s): difunde por broadcast el hash del
+     manifiesto actual — el faro Akasha que delata nuestra presencia en la
+     red de capa-2.
+- **Cola del userspace** — el demuxer empuja los frames no-AoE a una
+  `VecDeque<Vec<u8>>` con profundidad maxima 64; `sys_net_recibir` ahora
+  pasa por `akasha::pop_usuario(buf)` en lugar de leer directamente del
+  driver. Asi el kernel filtra Akasha sin disputarle paquetes al userspace.
+- **`tic_compositor`** — el punto de entrada de los oficios per-fotograma de
+  AoE, llamado desde el tic del compositor (cuyo latido es fiable). El
+  demuxer corre en cada vuelta; el faro se dispara cuando el reloj monotono
+  cruza `INTERVALO_FARO_MS` (5 s).
+- **Contadores** (`ResumenAkasha`): `rx_solicitudes`, `rx_proveedores`,
+  `rx_anuncios`, `tx_*` equivalentes, `rx_descartados`, `usuario_encolados`,
+  `usuario_desbordados`. Quedaran de fundamento para un futuro indicador AoE
+  en la barra de tareas.
+
+### Cambiado
+- **`tarea_red`** vuelve a su rol simple: enviar UN ARP request al gateway de
+  QEMU al arrancar. El demuxer y el faro pasaron al tic del compositor —
+  cuyo latido cooperativo es el unico GARANTIZADO bajo carga del reactor.
+  Un bucle propio en `tarea_red` (intentado primero) escala mal porque la
+  cadencia de `EsperaFrame::await` se degrada cuando los apps WASM bajo
+  `wasmi` ocupan el reactor (cada tic de app son decenas de ms de
+  interprete); medirlo contra el reloj monotono y enganchar al compositor
+  resuelve la falla con limpieza.
+- **`sys_net_recibir`** lee de la cola del userspace que mantiene `akasha`,
+  no del driver. El bloque doc en `wasm/env.rs` lo refleja.
+- **`drivers::red::recibir_en`** queda como primitiva del driver con
+  `#[allow(dead_code)]`: ya no la consume el sistema, pero la conservamos
+  para futuras herramientas de diagnostico que quieran leer la cola RX cruda.
+- **Demuxer politico**: frames `0x88B5` con payload basura para postcard —
+  por ejemplo el saludo en texto plano de `pregon`— se cuentan en
+  `RX_DESCARTADOS` pero TAMBIEN viajan a la cola del userspace. Asi pregon
+  o cualquier otro app que comparta el EtherType experimental pueda
+  recibirlos sin que el kernel se los robe.
+
+### Verificado
+- `cargo test -p akasha` — seis pruebas en verde:
+  ```
+  test pruebas::anuncio_de_raiz_viaja_compacto ... ok
+  test pruebas::componer_y_analizar_solicitud_es_simetrico ... ok
+  test pruebas::ethertype_ajeno_se_distingue ... ok
+  test pruebas::frame_demasiado_corto_se_distingue ... ok
+  test pruebas::payload_invalido_se_distingue ... ok
+  test pruebas::proveedor_lleva_payload_arbitrario ... ok
+  ```
+- QEMU headless 60 s, `-object filter-dump,file=/tmp/renaser-aoe.pcap`. El
+  pcap captura 14 frames:
+  ```
+  ARP: 2  (request del kernel + reply del gateway)
+  pregon: 1  (saludo texto plano)
+  AnunciarRaiz: 11  (faros del kernel, Δ promedio 5.86 s sobre 60 s)
+  ```
+  Cada AnunciarRaiz lleva como payload el hash del manifiesto:
+  `2f3deadfcc7dae25..` (postcard de 33 bytes — variante + hash — sobre un
+  frame Ethernet total de 47 bytes).
+- COM1 vuelca `akasha :: ANUNCIO emitido :: raiz=2f3deadfcc7dae25..` por
+  cada disparo; en una corrida de 60 s aparecen 11 anuncios consecutivos.