feat: support range(start, end, step) in for-loops

3-arg range desugars to ForIterable::Expr(Call("range",...)) so it
routes through the existing range() builtin that already handles step
and negative step (countdown). Preserves the fast ForIterable::Range
path for range(n) and range(start, end).

18/18 parser-extras tests, 1360/1360 full suite.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: RandomCoder-lab

examples/tests/test_parser_extras.omc

@@ -148,3 +148,29 @@ fn test_power_aug_assign() {
     y **= 8;
     assert_eq(y, 256, "y **= 8");
 }
+
+# ---- range(start, end, step) ----
+
+fn test_range_step_forward() {
+    h total = 0;
+    for i in range(0, 10, 2) {
+        total += i;
+    }
+    assert_eq(total, 20, "range(0,10,2) sum=20");
+}
+
+fn test_range_step_countdown() {
+    h total = 0;
+    for i in range(5, 0, -1) {
+        total += i;
+    }
+    assert_eq(total, 15, "range(5,0,-1) sum=15");
+}
+
+fn test_range_step_skip() {
+    h count = 0;
+    for i in range(1, 10, 3) {
+        count += 1;
+    }
+    assert_eq(count, 3, "range(1,10,3) has 3 elements: 1,4,7");
+}

omnimcode-core/src/parser.rs

@@ -1402,12 +1402,28 @@ impl Parser {
             self.advance();
             self.expect(Token::LParen)?;
             let first = self.parse_expression()?;
-            // Canonical OMC supports both range(end) and range(start, end).
+            // Canonical OMC supports range(end), range(start, end), and
+            // range(start, end, step). The fast ForIterable::Range path is used
+            // for the first two forms; a 3-arg range desugars to a builtin call
+            // (ForIterable::Expr) which the interpreter evaluates via range().
             if self.current() == Token::Comma {
                 self.advance();
-                let end = self.parse_expression()?;
-                self.expect(Token::RParen)?;
-                ForIterable::Range { start: first, end }
+                let second = self.parse_expression()?;
+                if self.current() == Token::Comma {
+                    // range(start, end, step) — desugar to Expr(Call("range", ...))
+                    self.advance();
+                    let step = self.parse_expression()?;
+                    self.expect(Token::RParen)?;
+                    let pos = crate::ast::Pos { line: 0, col: 0 };
+                    ForIterable::Expr(Expression::Call {
+                        name: "range".to_string(),
+                        args: vec![first, second, step],
+                        pos,
+                    })
+                } else {
+                    self.expect(Token::RParen)?;
+                    ForIterable::Range { start: first, end: second }
+                }
             } else {
                 self.expect(Token::RParen)?;
                 ForIterable::Range {