feat(charka): EVALUATE — el case de COBOL

EVALUATE atraviesa el pipeline entero — antes el parser lo guardaba
crudo como Stmt::Unknown.

- IR: Stmt::Evaluate { subject, whens, other } con
  WhenBranch { values, body }. Varios WHEN apilados comparten cuerpo;
  WHEN OTHER es el caso por defecto.
- Parser: EVALUATE subject WHEN v1 WHEN v2 ... [WHEN OTHER ...]
  END-EVALUATE.
- Codegen: lo baja a una cadena if / else if / else — una rama se
  elige si el sujeto es igual a alguno de sus valores, sin caída.
- Shadow: el intérprete evalúa el sujeto y ejecuta la primera rama
  cuyos valores casen, o el WHEN OTHER.
- Corpus: programa nuevo 09-evaluar (EVALUATE por valor anidado en un
  PERFORM VARYING, con WHEN apilados y WHEN OTHER). Verificado: el
  intérprete sombra y el crate compilado por scaffold dan la misma
  salida.

Alcance v1: EVALUATE por igualdad de valor; no la forma EVALUATE TRUE
con condiciones ni los rangos THRU.

Tests: charka-ir 19, charka-codegen 16, charka-shadow 14. fmt +
clippy limpios.

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

crates/modules/charka/charka-shadow/src/interp.rs

@@ -224,6 +224,22 @@ impl<'a> Machine<'a> {
                     self.exec_block(else_branch)
                 }
             }
+            Stmt::Evaluate {
+                subject,
+                whens,
+                other,
+            } => {
+                for branch in whens {
+                    if branch
+                        .values
+                        .iter()
+                        .any(|v| self.operands_equal(subject, v))
+                    {
+                        return self.exec_block(&branch.body);
+                    }
+                }
+                self.exec_block(other)
+            }
             Stmt::Perform(p) => self.exec_perform(p),
             Stmt::GoTo { target } => {
                 // Aproximación: ejecuta el destino y sale del párrafo.
@@ -438,6 +454,15 @@ impl<'a> Machine<'a> {
         }
     }
 
+    /// ¿Son iguales dos operandos? (Para las ramas `WHEN` del `EVALUATE`.)
+    fn operands_equal(&self, a: &Operand, b: &Operand) -> bool {
+        if self.is_text(a) || self.is_text(b) {
+            cobol_text_cmp(&self.eval_text(a), &self.eval_text(b)).is_eq()
+        } else {
+            self.eval_decimal(a) == self.eval_decimal(b)
+        }
+    }
+
     /// La suma de una lista de operandos.
     fn fold_sum(&self, ops: &[Operand]) -> Decimal {
         let mut acc = Decimal::zero();