feat(charka): PERFORM VARYING — el bucle con variable de control

El bucle más usado de COBOL, que antes el parser degradaba a un
PERFORM vacío (un hueco de corrección real). Ahora atraviesa el
pipeline entero como una rebanada vertical.

- IR: PerformControl::Varying { var, from, by, until }.
- Parser: reconoce PERFORM VARYING var FROM x BY y UNTIL cond en
  línea (END-PERFORM) y fuera de línea (PERFORM párrafo VARYING ...).
- Codegen: emite var = from; while !(until) { cuerpo; var += by; }.
- Shadow: el intérprete inicializa la variable, evalúa la condición
  antes de cada vuelta e incrementa al final.
- Corpus: programa nuevo 08-varying (suma 1..10). Verificado: el
  intérprete sombra y el crate compilado por scaffold dan ambos
  SUMA 1 A 10 = 00055 — las dos rutas concuerdan.

Tests: charka-ir 18, charka-codegen 15, charka-shadow 13. fmt +
clippy limpios.

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

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

@@ -265,6 +265,28 @@ impl<'a> Machine<'a> {
                     return Flow::Stop;
                 }
             },
+            PerformControl::Varying {
+                var,
+                from,
+                by,
+                until,
+            } => {
+                let start = self.eval_decimal(from);
+                self.store(var, start, false);
+                loop {
+                    if self.tick() {
+                        return Flow::Stop;
+                    }
+                    if self.eval_cond(until) {
+                        return Flow::Normal;
+                    }
+                    if let Flow::Stop = self.run_target(&p.target) {
+                        return Flow::Stop;
+                    }
+                    let next = self.field_value(var).add(&self.eval_decimal(by));
+                    self.store(var, next, false);
+                }
+            }
         }
     }
 

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

@@ -116,6 +116,7 @@ mod tests {
     corpus_test!(corpus_05_factorial, "05-factorial");
     corpus_test!(corpus_06_nomina, "06-nomina");
     corpus_test!(corpus_07_clasificar, "07-clasificar");
+    corpus_test!(corpus_08_varying, "08-varying");
 
     #[test]
     fn empty_source_runs_clean() {
@@ -146,6 +147,27 @@ mod tests {
         assert_eq!(outcome.halt, Halt::StepLimit);
     }
 
+    #[test]
+    fn perform_varying_out_of_line() {
+        // `PERFORM CONTAR VARYING ...` — el párrafo es el cuerpo del bucle.
+        // WS-I = 1, 3, 5, 7, 9 (FROM 1 BY 2 UNTIL > 9) → 5 iteraciones.
+        let outcome = run_source(
+            "DATA DIVISION.\n\
+             WORKING-STORAGE SECTION.\n\
+             01 WS-I PIC 9(2) VALUE 0.\n\
+             01 WS-N PIC 9(3) VALUE 0.\n\
+             PROCEDURE DIVISION.\n\
+             MAIN.\n\
+                 PERFORM CONTAR VARYING WS-I FROM 1 BY 2 UNTIL WS-I > 9.\n\
+                 DISPLAY WS-N.\n\
+                 STOP RUN.\n\
+             CONTAR.\n\
+                 ADD 1 TO WS-N.\n",
+        )
+        .expect("pipeline OK");
+        assert_eq!(outcome.lines, vec!["005".to_string()]);
+    }
+
     #[test]
     fn lex_error_surfaces() {
         let err = run_source("PROCEDURE DIVISION.\nMAIN.\n DISPLAY 'sin cerrar.\n").unwrap_err();