lang: extend operand-type check to ordering + bitwise/shift (issue 0055 follow-up)

The arithmetic-only check from the previous commit shared a hole with the
comparison and bitwise/shift ops: lowerBinaryOp derives the result type
from the LHS, so `s64 < string` fed mismatched types to `icmp` (LLVM
verifier failure) and `s64 & string` reinterpreted the string's bytes.

Add isOrderingOperand (numeric / enum / pointer / bool / vector) and
isBitwiseOperand (integer / enum / bool / vector), and route `< <= > >=`
and `& | ^ << >>` through them alongside the existing arithmetic check, all
sharing one diagnostic + placeholder-sentinel path. Flags-enum bitwise
(`.read | .write`, `perm & .read`), enum/pointer comparison, and int
literals stay legal (50-smoke unaffected).

Equality `== / !=` is deliberately left unchecked — its path is heavily
special-cased (str_eq, Any unbox, optional == null); folding a check in
without regressing those is a separate change, noted in the issue.

Regression test renamed arith→binop and broadened to cover `+ * < & <<`
against a string operand: examples/214-binop-operand-type-check.sx.

examples/214-arith-operand-type-check.sx

@@ -1,15 +0,0 @@
-// Scalar arithmetic (`+ - * / %`) requires numeric operands. Mixing a
-// non-numeric type (here `string`) is rejected at compile time. The
-// result type is otherwise taken from the left operand, so without this
-// check `n + s` would lower as `add : s64` and reinterpret the string's
-// bytes as an integer — silently producing garbage.
-
-#import "modules/std.sx";
-
-main :: () -> s32 {
-    n : s64 = 40;
-    s : string = "nope";
-    x := n + s;     // s64 + string — rejected
-    y := s * n;     // string * s64 — rejected (non-numeric LHS too)
-    0;
-}

examples/214-binop-operand-type-check.sx

@@ -0,0 +1,25 @@
+// Scalar binary operators check operand-type compatibility. The result
+// type is otherwise taken from the left operand, so mixing a non-numeric
+// type (here `string`) would lower as `<op> : s64` and either reinterpret
+// the string's bytes (arithmetic / bitwise → garbage) or feed mismatched
+// types to `icmp` (ordering → LLVM verifier failure). All such mismatches
+// are now rejected at compile time:
+//   - arithmetic `+ - * / %`  (numeric / vector / pointer operands)
+//   - ordering   `< <= > >=`  (numeric / enum / pointer operands)
+//   - bitwise    `& | ^`      (integer / enum operands)
+//   - shift      `<< >>`      (integer / enum operands)
+// Legitimate mixes (int+float promotion, flags-enum bitwise, enum/pointer
+// comparison) are unaffected — see `examples/50-smoke.sx`.
+
+#import "modules/std.sx";
+
+main :: () -> s32 {
+    n : s64 = 40;
+    s : string = "nope";
+    a := n + s;      // arithmetic: s64 + string
+    b := s * n;      // arithmetic: non-numeric LHS (string * s64)
+    c := n < s;      // ordering:   s64 < string
+    d := n & s;      // bitwise:    s64 & string
+    e := n << s;     // shift:      s64 << string
+    0;
+}