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-codegen/src/lib.rs

@@ -350,6 +350,21 @@ mod tests {
         assert!(out.contains("self.ws_i.store(self.ws_i.value().add(&(dec(\"1\"))));"));
     }
 
+    #[test]
+    fn evaluate_emits_an_if_else_chain() {
+        let out = gen("DATA DIVISION.\n\
+             WORKING-STORAGE SECTION.\n\
+             01 WS-X PIC 9(1).\n\
+             PROCEDURE DIVISION.\n\
+             MAIN.\n\
+                 EVALUATE WS-X\n\
+                     WHEN 1 DISPLAY 'UNO'\n\
+                     WHEN OTHER DISPLAY 'OTRO'\n\
+                 END-EVALUATE.\n");
+        assert!(out.contains("if ((self.ws_x.value()) == (dec(\"1\"))) {"));
+        assert!(out.contains("} else {"));
+    }
+
     #[test]
     fn empty_program_still_compiles_shape() {
         let out = gen("");

crates/modules/charka/charka-codegen/src/stmt.rs

@@ -1,7 +1,7 @@
 //! Emisión de los statements del PROCEDURE: cada [`Stmt`] se traduce a
 //! una o varias líneas de código Rust sobre `charka-runtime`.
 
-use charka_ir::{Operand, Perform, PerformControl, PerformTarget, Stmt};
+use charka_ir::{CmpOp, Cond, Operand, Perform, PerformControl, PerformTarget, Stmt, WhenBranch};
 
 use crate::emit::Emitter;
 use crate::expr::{
@@ -73,6 +73,11 @@ pub(crate) fn emit_stmt(em: &mut Emitter, sym: &Symbols, stmt: &Stmt) {
                 em.line("}");
             }
         }
+        Stmt::Evaluate {
+            subject,
+            whens,
+            other,
+        } => emit_evaluate(em, sym, subject, whens, other),
         Stmt::Perform(p) => emit_perform(em, sym, p),
         Stmt::GoTo { target } => {
             em.line(&format!(
@@ -321,6 +326,72 @@ fn count_expr(sym: &Symbols, op: &Operand) -> String {
     }
 }
 
+/// Emite un `EVALUATE` como una cadena `if / else if / else`.
+fn emit_evaluate(
+    em: &mut Emitter,
+    sym: &Symbols,
+    subject: &Operand,
+    whens: &[WhenBranch],
+    other: &[Stmt],
+) {
+    if whens.is_empty() {
+        if !other.is_empty() {
+            em.line("{");
+            em.indent();
+            emit_block(em, sym, other);
+            em.dedent();
+            em.line("}");
+        }
+        return;
+    }
+    for (i, branch) in whens.iter().enumerate() {
+        let cond = branch_condition(sym, subject, branch);
+        if i == 0 {
+            em.line(&format!("if {cond} {{"));
+        } else {
+            em.line(&format!("}} else if {cond} {{"));
+        }
+        em.indent();
+        emit_block(em, sym, &branch.body);
+        em.dedent();
+    }
+    if other.is_empty() {
+        em.line("}");
+    } else {
+        em.line("} else {");
+        em.indent();
+        emit_block(em, sym, other);
+        em.dedent();
+        em.line("}");
+    }
+}
+
+/// La condición de una rama `WHEN`: el sujeto igual a cualquiera de
+/// sus valores.
+fn branch_condition(sym: &Symbols, subject: &Operand, branch: &WhenBranch) -> String {
+    if branch.values.is_empty() {
+        return "false".to_string();
+    }
+    branch
+        .values
+        .iter()
+        .map(|v| {
+            format!(
+                "({})",
+                emit_cond(
+                    sym,
+                    &Cond::Compare {
+                        lhs: subject.clone(),
+                        op: CmpOp::Eq,
+                        rhs: v.clone(),
+                    },
+                )
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(" || ")
+}
+
 fn emit_perform(em: &mut Emitter, sym: &Symbols, p: &Perform) {
     // Emite el "cuerpo": la llamada al párrafo o el bloque en línea.
     let emit_body = |em: &mut Emitter, sym: &Symbols| match &p.target {