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-ir/src/ast.rs

@@ -155,6 +155,15 @@ pub enum Stmt {
         then_branch: Vec<Stmt>,
         else_branch: Vec<Stmt>,
     },
+    /// `EVALUATE subject WHEN ... [WHEN OTHER ...] END-EVALUATE` — el
+    /// `case` de COBOL. Una rama se elige si `subject` es igual a
+    /// alguno de sus valores; sin caída entre ramas.
+    Evaluate {
+        subject: Operand,
+        whens: Vec<WhenBranch>,
+        /// El cuerpo de `WHEN OTHER` (vacío si no hay).
+        other: Vec<Stmt>,
+    },
     /// `PERFORM ...` — ver [`Perform`].
     Perform(Perform),
     /// `GO TO target`
@@ -172,6 +181,14 @@ pub enum Stmt {
     Unknown { verb: String, tokens: Vec<Token> },
 }
 
+/// Una rama `WHEN` de un `EVALUATE`: los valores que la disparan
+/// (varios `WHEN` apilados comparten cuerpo) y el cuerpo a ejecutar.
+#[derive(Debug, Clone, PartialEq)]
+pub struct WhenBranch {
+    pub values: Vec<Operand>,
+    pub body: Vec<Stmt>,
+}
+
 /// Un statement `PERFORM`: a quién ejecuta y cuántas veces.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Perform {

crates/modules/charka/charka-ir/src/lib.rs

@@ -16,9 +16,9 @@
 //! Alcance v1 — los verbos parseados a fondo: `MOVE`, `DISPLAY`,
 //! `ACCEPT`, `COMPUTE` (con expresiones con precedencia), `ADD`,
 //! `SUBTRACT`, `MULTIPLY`, `DIVIDE`, `IF`/`ELSE`/`END-IF` (con
-//! condiciones `AND`/`OR`/`NOT`), `PERFORM` (fuera de línea, en línea,
-//! `TIMES`, `UNTIL`, `VARYING`), `GO TO`, `STOP RUN`, `GOBACK`,
-//! `EXIT`, `CONTINUE`. Fuera de alcance: `EVALUATE`,
+//! condiciones `AND`/`OR`/`NOT`), `EVALUATE`/`WHEN`, `PERFORM` (fuera
+//! de línea, en línea, `TIMES`, `UNTIL`, `VARYING`), `GO TO`,
+//! `STOP RUN`, `GOBACK`, `EXIT`, `CONTINUE`. Fuera de alcance:
 //! `STRING`/`UNSTRING`, E/S de ficheros, CICS y SQL embebido.
 
 #![forbid(unsafe_code)]
@@ -311,6 +311,34 @@ mod tests {
         }
     }
 
+    #[test]
+    fn evaluate_parses_whens_and_other() {
+        let b = body(
+            "EVALUATE WS-X \
+             WHEN 1 DISPLAY 'A' \
+             WHEN 2 WHEN 3 DISPLAY 'B' \
+             WHEN OTHER DISPLAY 'C' \
+             END-EVALUATE.",
+        );
+        match &b[0] {
+            Stmt::Evaluate {
+                subject,
+                whens,
+                other,
+            } => {
+                assert_eq!(subject, &Operand::Data("WS-X".into()));
+                assert_eq!(whens.len(), 2);
+                assert_eq!(whens[0].values, vec![Operand::Num("1".into())]);
+                assert_eq!(
+                    whens[1].values,
+                    vec![Operand::Num("2".into()), Operand::Num("3".into())]
+                );
+                assert_eq!(other.len(), 1);
+            }
+            other => panic!("se esperaba EVALUATE, vino {other:?}"),
+        }
+    }
+
     #[test]
     fn several_statements_in_one_sentence() {
         let b = body("MOVE 1 TO X DISPLAY X STOP RUN.");

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

@@ -5,7 +5,7 @@
 
 use charka_parser::TokenKind;
 
-use crate::ast::{Operand, Perform, PerformControl, PerformTarget, Stmt};
+use crate::ast::{Operand, Perform, PerformControl, PerformTarget, Stmt, WhenBranch};
 use crate::cursor::{parse_operand, Cursor};
 use crate::expr::{parse_cond, parse_expr};
 use crate::kw::{is_boundary, is_terminator, is_verb};
@@ -38,6 +38,7 @@ fn parse_one_stmt(c: &mut Cursor, stops: &[&str]) -> Stmt {
         "MULTIPLY" => parse_multiply(c),
         "DIVIDE" => parse_divide(c),
         "IF" => parse_if(c),
+        "EVALUATE" => parse_evaluate(c),
         "PERFORM" => parse_perform(c),
         "GO" => parse_goto(c),
         "STOP" => parse_stop(c),
@@ -285,6 +286,40 @@ fn parse_if(c: &mut Cursor) -> Stmt {
     }
 }
 
+fn parse_evaluate(c: &mut Cursor) -> Stmt {
+    c.bump(); // EVALUATE
+    let subject = parse_operand(c);
+    let mut whens = Vec::new();
+    let mut other = Vec::new();
+    while !c.done() && !c.at_word("END-EVALUATE") {
+        if !c.at_word("WHEN") {
+            break; // algo inesperado dentro del EVALUATE: se corta
+        }
+        // Varios `WHEN` apilados comparten el mismo cuerpo.
+        let mut values = Vec::new();
+        let mut is_other = false;
+        while c.eat_word("WHEN") {
+            if c.eat_word("OTHER") {
+                is_other = true;
+            } else {
+                values.push(parse_operand(c));
+            }
+        }
+        let body = parse_statements(c, &["WHEN", "END-EVALUATE"]);
+        if is_other {
+            other = body;
+        } else {
+            whens.push(WhenBranch { values, body });
+        }
+    }
+    c.eat_word("END-EVALUATE");
+    Stmt::Evaluate {
+        subject,
+        whens,
+        other,
+    }
+}
+
 fn parse_perform(c: &mut Cursor) -> Stmt {
     c.bump(); // PERFORM