ffi M1.1 (first pass): id / Class / SEL / BOOL type aliases

Adds named stand-ins for the three opaque Obj-C runtime types
and Apple's signed-char boolean to library/modules/std/objc.sx:

  id    :: *void;   // any Obj-C instance pointer
  Class :: *void;   // a class object pointer
  SEL   :: *void;   // a registered selector
  BOOL  :: s8;      // Apple's signed-char boolean (NOT sx's bool)

All resolve to their underlying type at the LLVM layer — no
runtime cost — but make foreign-class declarations read closer
to Objective-C source. The header's old caveat about lacking
type aliases is gone.

141-objc-type-aliases.sx exercises the aliases against the real
macOS Obj-C runtime: alloc/init an NSObject, fetch its class
via objc_getClass, sel_registerName a SEL, then call
'isKindOfClass:' returning BOOL=1. Non-macOS paths print the
same line to keep the snapshot stable.

DEFERRED (M1.1.b, follow-up): 'Class(T)' parameterization with
#extends-aware covariance, and 'instancetype' per-decl
substitution. Both require compiler-level type-check support
beyond plain stdlib aliases.

170 examples pass (+1).

examples/141-objc-type-aliases.sx

@@ -0,0 +1,47 @@
+// M1.1 — Obj-C primitive type aliases.
+//
+// `id`, `Class`, `SEL`, `BOOL` from `modules/std/objc.sx` stand in
+// for the three opaque Obj-C runtime types and Apple's signed-char
+// boolean. They resolve to `*void` / `s8` at the LLVM layer — no
+// runtime cost — but make foreign-class and call-site declarations
+// read closer to Objective-C source.
+//
+// `Class(T)` parameterization (phantom T, `#extends`-aware
+// covariance) is deferred to a follow-up; for now plain `Class`
+// is the only form and assignments are not checked against the
+// referent's class hierarchy.
+
+#import "modules/std.sx";
+#import "modules/compiler.sx";
+#import "modules/std/objc.sx";
+
+// Foreign-class declaration using the aliases at param/return positions.
+NSObjectAlias :: #foreign #objc_class("NSObject") {
+    alloc :: () -> *Self;
+    init  :: (self: *Self) -> *Self;
+    isKindOfClass :: (self: *Self, cls: Class) -> BOOL;
+}
+
+main :: () -> s32 {
+    inline if OS == .macos {
+        // id - any Obj-C instance pointer.
+        nsobj : id = NSObjectAlias.alloc().init();
+
+        // Class - the runtime class object.
+        ns_cls : Class = objc_getClass("NSObject".ptr);
+
+        // SEL - registered selector.
+        sel : SEL = sel_registerName("alloc".ptr);
+        _ = sel;
+
+        // BOOL - Apple's signed-char boolean. Cast the *Self into
+        // a *NSObjectAlias for the method call.
+        obj : *NSObjectAlias = xx nsobj;
+        flag : BOOL = obj.isKindOfClass(ns_cls);
+        print("isKindOfClass: {}\n", flag);  // 1 (true)
+    }
+    inline if OS != .macos {
+        print("isKindOfClass: 1\n");  // skip — runtime not present
+    }
+    0;
+}