feat: añadir arena generacional segura

docs/superpowers/plans/2026-07-29-rust-performance-course.md

@@ -128,7 +128,7 @@ su dependencia.
 ### Capítulo 07: arenas seguras y ciclos de vida
 
 - [x] #21 Especificar arena segura, capacidad, reset y alternativas.
-- [ ] #22 Implementar y probar una arena educativa sin `unsafe`.
+- [x] #22 Implementar y probar una arena educativa sin `unsafe`.
 - [ ] #23 Escribir capítulo, diagrama, ejemplos, ejercicios y benchmarks.
 
 ## Milestone 3: Movimiento de datos y SIMD

src/arena.rs

@@ -0,0 +1,65 @@
+//! Arena educativa segura basada en índices y generaciones.
+
+/// Identificador válido únicamente dentro de una generación de arena.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct ArenaId {
+    index: usize,
+    generation: u64,
+}
+
+/// Colección de valores con invalidación explícita mediante `reset`.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SafeArena<T> {
+    values: Vec<T>,
+    generation: u64,
+}
+
+impl<T> SafeArena<T> {
+    /// Construye una arena sin capacidad reservada.
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            values: Vec::new(),
+            generation: 0,
+        }
+    }
+
+    /// Construye una arena con capacidad inicial explícita.
+    #[must_use]
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            values: Vec::with_capacity(capacity),
+            generation: 0,
+        }
+    }
+
+    /// Inserta un valor y devuelve un identificador de la generación actual.
+    pub fn insert(&mut self, value: T) -> ArenaId {
+        let id = ArenaId {
+            index: self.values.len(),
+            generation: self.generation,
+        };
+        self.values.push(value);
+        id
+    }
+
+    /// Obtiene un valor si su identificador pertenece a la generación actual.
+    #[must_use]
+    pub fn get(&self, id: ArenaId) -> Option<&T> {
+        (id.generation == self.generation)
+            .then(|| self.values.get(id.index))
+            .flatten()
+    }
+
+    /// Elimina todos los valores e invalida los identificadores anteriores.
+    pub fn reset(&mut self) {
+        self.values.clear();
+        self.generation = self.generation.wrapping_add(1);
+    }
+}
+
+impl<T> Default for SafeArena<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/lib.rs

@@ -7,6 +7,7 @@
 #![forbid(unsafe_code)]
 
 pub mod allocation;
+pub mod arena;
 pub mod benchmark;
 pub mod layout;
 pub mod locality;

tests/safe_arena.rs

@@ -0,0 +1,20 @@
+use rust_performance::arena::SafeArena;
+
+#[test]
+fn retrieves_values_inserted_in_the_current_generation() {
+    let mut arena = SafeArena::with_capacity(2);
+    let id = arena.insert("valor");
+
+    assert_eq!(arena.get(id), Some(&"valor"));
+}
+
+#[test]
+fn reset_invalidates_previous_identifiers() {
+    let mut arena = SafeArena::new();
+    let old = arena.insert(7);
+    arena.reset();
+    let current = arena.insert(9);
+
+    assert_eq!(arena.get(old), None);
+    assert_eq!(arena.get(current), Some(&9));
+}