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/ROADMAP.md

@@ -357,6 +357,49 @@ Líneas abiertas posteriores: una pila mínima ARP/IP/UDP para los apps;
 un servidor de eco / un cliente DNS de juguete; reciclado de las
 ranuras de ventana cerradas; audio con varias voces (PCM).
 
+## Fase 20 — Akasha Over Ether: el grafo distribuido (completada)
+
+El grafo de objetos persistentes —direccionado por contenido, ya BLAKE3—
+deja de ser una propiedad LOCAL del disco y se vuelve una propiedad
+DISTRIBUIDA del cable. Sin TCP, sin IP, sin DNS: tres mensajes y un
+EtherType propio bastan.
+
+- Crate `akasha/` (no_std compartido, gemela de `formato`): el
+  protocolo. `MensajeAkasha` con `SolicitarObjeto(id)`,
+  `ProveedorObjeto(id, payload)`, `AnunciarRaiz(id)`. Serializado con
+  `postcard`. Helpers `componer_frame` y `analizar_frame`. EtherType
+  experimental `0x88B5`. Seis pruebas unitarias.
+- Módulo `kernel/src/akasha.rs`: el respondedor. Drena la cola RX del
+  dispositivo de red y **demultiplexa**: los frames AoE legítimos los
+  procesa en el núcleo; el resto va a una cola del userspace que
+  `sys_net_recibir` lee. Atiende `SolicitarObjeto` consultando
+  `almacen`, absorbe `ProveedorObjeto` verificando integridad, registra
+  `AnunciarRaiz` y, si ignoramos el nodo anunciado, le pedimos al emisor.
+- Faro periódico: cada 5 s, `AnunciarRaiz` con el hash del manifiesto se
+  difunde por broadcast. La cadencia se mide contra el reloj monótono —
+  no contra los awaits—, por lo que el ritmo del faro es independiente
+  de cuánto trabajo del reactor consume cada vuelta.
+- `tic_compositor`: el pulso fiable. Los oficios AoE se enganchan al tic
+  del compositor (cuyo latido cooperativo es el único garantizado bajo
+  carga del reactor); una tarea propia con `EsperaFrame::await` en bucle
+  no escalaba porque el intérprete `wasmi` de los apps degrada la
+  cadencia de los awaits a varios cientos de ms.
+- `sys_net_recibir` lee de la cola del userspace que mantiene `akasha`,
+  no del driver. `drivers::red::recibir_en` queda como primitiva del
+  driver para futuras herramientas de diagnóstico.
+
+Verificada con `cargo test -p akasha` (6 pruebas verdes) y con QEMU
+headless + `-object filter-dump`. En 60 s de captura: 11 `AnunciarRaiz`
+con Δ promedio 5.86 s, un ARP request + reply y el saludo en texto
+plano de `pregon`. La casa ya tiene su propio idioma de red — y un faro
+que late.
+
+Líneas abiertas posteriores: una pila ARP/IP/UDP mínima para los apps;
+un peer real en una segunda VM para ver la replicación end-to-end
+`AnunciarRaiz → SolicitarObjeto → ProveedorObjeto`; un indicador AoE en
+la barra de tareas que pinte los contadores de `ResumenAkasha`;
+reciclado de las ranuras de ventana cerradas; audio con varias voces.
+
 ## Principios que persisten entre fases
 
 - Reutilizar infraestructura madura de la comunidad antes que reinventar.