issues: promote 6 fixed bug repros to focused regression tests

All six produce their target outputs cleanly today; renamed out of
the `issue-*` namespace per CLAUDE.md "Resolving an open issue":

| Old                  | New                                       |
|----------------------|-------------------------------------------|
| issue-0032           | 181-impl-duplicate-same-file              |
| issue-0041           | 182-compound-type-in-expression           |
| issue-0042           | 183-type-alias-size-align                 |
| issue-0044           | 184-objc-defined-class-method-self        |
| issue-0045           | 185-pack-fn-comptime-return               |
| issue-0046           | 186-nested-comptime-return                |

Comment headers tightened to feature-focused (drop the issue-NNNN
provenance — that's in git history now). Missing expected `.txt` /
`.exit` files captured for 0041 + 0042 (they were untracked because
the bugs were fixed silently in adjacent work).

`examples/issue-*` after this commit: just `issue-0030.sx` — a
feature request (`extern G : T;` cross-file globals) that's never
been implemented. Staying in the issue namespace as a parked
proposal until the feature lands or gets formally rejected.

220/220 example tests + `zig build test` green.

examples/184-objc-defined-class-method-self.sx

@@ -0,0 +1,108 @@
+// `xx self` inside a BOOL-returning `#objc_class` method must
+// resolve to the full receiver pointer at a foreign-class method
+// call site, not get truncated to i8 by the enclosing function's
+// BOOL return type. Regression locks in the
+// `resolveCallParamTypes` fix that threads foreign-class method
+// param types correctly even when the receiver is a `#foreign
+// #objc_class` alias. Every probe round-trips the receiver pointer
+// — a regression would read only the low byte and the observer
+// pointer would appear as e.g. 0xC0 / 0x20 instead of its real
+// 64-bit value.
+#import "modules/std.sx";
+#import "modules/std/objc.sx";
+#import "modules/compiler.sx";
+
+g_observer : *void = null;
+
+// Stand-in for NSNotificationCenter — we just need a foreign-class
+// method with several *void args so the call site's arg-target-type
+// resolution exercises the same path as uikit.sx's keyboard observer.
+SxIssue44Bus :: #foreign #objc_class("NSNotificationCenter") {
+    defaultCenter :: () -> *SxIssue44Bus;
+    addObserver_selector_name_object :: (self: *Self, observer: *void, sel: *void, name: *void, obj: *void);
+}
+
+SxIssue44Foo :: #objc_class("SxIssue44Foo") {
+    counter: s32;
+    sentinel: *void;
+
+    alloc :: () -> *SxIssue44Foo;
+
+    bump :: (this: *Self) {
+        this.counter += 1;
+    }
+
+    get :: (this: *Self) -> s32 {
+        return this.counter;
+    }
+
+    // Return the receiver — direct `xx this` round-trip.
+    me :: (this: *Self) -> *void {
+        return xx this;
+    }
+
+    // SxAppDelegate-shape: BOOL return + 2 extra *void args. Pre-fix,
+    // the call to addObserver:... would receive `xx this` truncated to
+    // its low byte (because resolveCallParamTypes returned `&.{}` for
+    // foreign-class receivers and `self.target_type` leaked the BOOL
+    // return type into the call's args).
+    appDelegate_options :: (this: *Self, app: *void, opts: *void) -> BOOL {
+        bus := SxIssue44Bus.defaultCenter();
+        bus.addObserver_selector_name_object(
+            xx this,
+            xx 0,
+            xx 0,
+            null);
+        return 1;
+    }
+
+    // Same shape but captures the observer-equivalent value to a global
+    // so we can read it back without going through NSNotificationCenter
+    // (which would crash with a real observer != NSObject subclass).
+    captureSelf_options :: (this: *Self, app: *void, opts: *void) -> BOOL {
+        capture_observer(xx this);
+        return 1;
+    }
+}
+
+capture_observer :: (p: *void) {
+    g_observer = p;
+}
+
+main :: () -> s32 {
+    inline if OS == .macos {
+        f := SxIssue44Foo.alloc();
+        if f == null { print("FAIL: alloc returned null\n"); return 1; }
+
+        f.bump();
+        f.bump();
+        f.bump();
+        print("counter: {}\n", f.get());
+
+        // Direct `xx this` round-trip (worked pre-fix).
+        f_void : *void = xx f;
+        if f.me() == f_void {
+            print("me: ok\n");
+        } else {
+            print("me: WRONG\n");
+        }
+
+        // The actual repro: BOOL return + foreign-class method call.
+        // Pre-fix: `xx this` truncated to i8, capture_observer receives
+        // (low_byte_of_f) cast back to *void, which won't equal f_void.
+        g_observer = null;
+        _ = f.captureSelf_options(xx 0, xx 0);
+        if g_observer == f_void {
+            print("captureSelf-from-BOOL: ok\n");
+        } else {
+            print("captureSelf-from-BOOL: WRONG\n");
+        }
+
+        // Also exercise the compile-only path — appDelegate_options' IR
+        // must pass `ptr` args to objc_msgSend (not `i8`). We don't
+        // dispatch this for real (would crash inside NSNotificationCenter),
+        // but the build pulling cleanly through is half the point.
+    }
+    inline if OS != .macos { print("skipped (not macos)\n"); }
+    0;
+}