lang: range bound markers — '=' inclusive / '<' exclusive on either side of '..'

Each side of '..' takes an optional bound marker, defaulting to
start-inclusive, end-exclusive (a..b == a=..<b; a..=b stays the short
end-inclusive spelling):

    for 0<..<N (i) { }   // 1 .. N-1   (both exclusive)
    for 0=..=N (i) { }   // 0 .. N     (both inclusive)
    for 0<..=N (i) { }   // 1 .. N
    for 0..<N  (i) { }   // 0 .. N-1   (explicit default)
    for xs, 2<.. (x, i)  // open range, exclusive start: i = 3, 4, ...

The nine lexemes are single tokens (maximal munch on '<'/'='/'..'), so
expression parsing never sees the leading marker as a comparison; '<',
'<<', '<=', '==', '=>' lex unchanged. An explicit end marker makes the
end expression mandatory; open forms are a.. / a<.. / a=... Works in
runtime, multi-iterable, and inline-for headers.

Regression: examples/0051-basic-for-range-bounds.sx (full matrix, open
start-marked ranges, comptime unroll, runtime bounds, lexer
non-regression); 1152's pinned message generalized.

examples/0051-basic-for-range-bounds.sx

@@ -0,0 +1,48 @@
+// Range bound markers: each side of `..` takes `=` (inclusive) or `<`
+// (exclusive); defaults are start-inclusive, end-exclusive (`a..b` == `a=..<b`).
+// Covers the full matrix, open ranges with start markers, comptime unrolling,
+// runtime bounds, and that `<` / `<<` comparisons still lex normally.
+
+#import "modules/std.sx";
+
+main :: () -> s32 {
+    for 0<..<5 (i) { print("{} ", i); }
+    print("| 0<..<5\n");
+    for 0=..=5 (i) { print("{} ", i); }
+    print("| 0=..=5\n");
+    for 0<..=5 (i) { print("{} ", i); }
+    print("| 0<..=5\n");
+    for 0=..<5 (i) { print("{} ", i); }
+    print("| 0=..<5\n");
+    for 0..<5 (i) { print("{} ", i); }
+    print("| 0..<5\n");
+    for 0..=5 (i) { print("{} ", i); }
+    print("| 0..=5\n");
+
+    // Exclusive-start open range following a bounded first iterable.
+    xs : [3]s64 = .[10, 20, 30];
+    for xs, 2<.. (x, i) { print("{}@{} ", x, i); }
+    print("| xs, 2<..\n");
+
+    // Explicit inclusive-start open form (synonym of `5..`).
+    for xs, 5=.. (x, i) { print("{}@{} ", x, i); }
+    print("| xs, 5=..\n");
+
+    // Comptime-unrolled with markers.
+    s := 0;
+    inline for 0<..=3 (i) { s += i; }
+    print("inline 0<..=3 sum={}\n", s);
+
+    // Runtime bounds with markers.
+    lo := 1;
+    hi := 4;
+    for lo<..=hi (i) { print("{} ", i); }
+    print("| lo<..=hi\n");
+
+    // Comparison operators still lex normally.
+    a := 3;
+    if a < 5 { print("cmp ok\n"); }
+    b := a << 1;
+    print("shl={}\n", b);
+    0
+}

examples/1152-diagnostics-for-inclusive-open.sx

@@ -1,4 +1,5 @@
-// `..=` is the inclusive bounded form — it requires an end expression.
+// A range with an explicit end marker (`..=` / `..<`) is the bounded form —
+// it requires an end expression; the open form is `a..`.
 
 #import "modules/std.sx";
 

examples/expected/0051-basic-for-range-bounds.exit

@@ -0,0 +1 @@
+0

examples/expected/0051-basic-for-range-bounds.stderr

@@ -0,0 +1 @@
+

examples/expected/0051-basic-for-range-bounds.stdout

@@ -0,0 +1,12 @@
+1 2 3 4 | 0<..<5
+0 1 2 3 4 5 | 0=..=5
+1 2 3 4 5 | 0<..=5
+0 1 2 3 4 | 0=..<5
+0 1 2 3 4 | 0..<5
+0 1 2 3 4 5 | 0..=5
+10@3 20@4 30@5 | xs, 2<..
+10@5 20@6 30@7 | xs, 5=..
+inline 0<..=3 sum=6
+2 3 4 | lo<..=hi
+cmp ok
+shl=6

examples/expected/1152-diagnostics-for-inclusive-open.stderr

@@ -1,5 +1,5 @@
-error: '..=' requires an end expression — the open form is 'a..'
-  --> examples/1152-diagnostics-for-inclusive-open.sx:6:14
+error: a range with an explicit end marker ('..=' / '..<') requires an end expression — the open form is 'a..'
+  --> examples/1152-diagnostics-for-inclusive-open.sx:7:14
    |
- 6 |     for 0..= (i) { }
+ 7 |     for 0..= (i) { }
    |              ^