ffi M5.A revert: drop compiler synthesis, require explicit Into(Block) impls

Reconsidered the M5.A.2 cleanup. The compiler-synthesised trampoline
path was hidden behaviour — a user reading their code couldn't tell
how `xx my_closure : Block` worked without reading lower.zig. That's
exactly the kind of magic sx's design has been pushing against.

New design (strict mode):

1. Stdlib's modules/std/objc_block.sx hand-rolls
   `__block_invoke_void` + `Into(Block) for Closure() -> void` and
   the same pair for `Closure(bool) -> void` (restored from M5.A.2).
   These are readable reference implementations of the bridge ABI.

2. The compiler intercept fires NO synthesis — instead, when
   `tryUserConversion` can't find a reachable `Into(Block)` impl for
   the closure's signature, it emits a focused diagnostic:
     "no `Into(Block) for <Closure-sig>` impl — add a per-signature
      `__block_invoke_<sig>` trampoline + Into impl alongside the
      existing ones in modules/std/objc_block.sx, or declare it in
      your own code"

3. Per-signature declarations live in stdlib (for common signatures)
   or in user code (for app-specific ones). 96-objc-block-multi-arg
   now demonstrates the user-side pattern in-file — it declares its
   own `__block_invoke_void_s32_p` + `Into(Block) for Closure(s32,
   *void) -> void` impl alongside its main().

Net effect:
- Every block bridge is source-visible. No hidden compiler magic.
- Users see exactly how the Apple ABI shape is constructed in sx
  source — stdlib serves as the reference implementation.
- Compiler enforces the discipline: missing impl → clear diagnostic
  pointing at the template.
- Coverage for arbitrary signatures requires conscious user opt-in,
  not silent fallthrough.

Removed from lower.zig: `tryClosureToBlockConversion`,
`emitBlockInvokeTrampoline`, `mangleClosureSigForBlock`,
`mangleTypeForBlock`, and the `block_invoke_trampolines` dedup
state field. Net: the synthesis machinery is gone; only the
detection helper `isClosureToBlockCast` remains, used by the
diagnostic.

190/190 example tests pass; chess on iOS-sim green.

examples/96-objc-block-multi-arg.sx

@@ -1,20 +1,44 @@
-// M5.A — `xx closure : Block` for an arbitrary closure signature.
+// `xx closure : Block` for an arbitrary closure signature.
 //
-// Pre-M5.A: the stdlib hand-rolled `Into(Block) for Closure(s32, *void) -> s32`
-// didn't exist — this code wouldn't compile. Only `Closure() -> void`
-// and `Closure(bool) -> void` shapes were supported.
+// The stdlib (modules/std/objc_block.sx) declares hand-rolled
+// `Into(Block) for Closure() -> void` and `Closure(bool) -> void`
+// impls — the two most common Apple block shapes. Other signatures
+// need a per-shape `__block_invoke_<sig>` trampoline + `Into(Block)`
+// impl declared somewhere reachable (stdlib if shared, in-file if
+// app-specific).
 //
-// Post-M5.A: the compiler synthesises `__block_invoke_i_i_p` for this
-// signature on the fly. The block's invoke trampoline forwards
-// `(__sx_default_context, sx_env, arg0, arg1)` to the captured closure
-// and returns the s32 result.
+// This test exercises the user-declared variant: signature
+// `Closure(s32, *void) -> void` (a two-arg block — not in stdlib).
+// If the impl is missing, the compiler emits a focused diagnostic
+// pointing at modules/std/objc_block.sx as the template.
 
 #import "modules/std.sx";
 #import "modules/std/objc_block.sx";
 
+// Trampoline matching `void (^)(int, void*)` — the C ABI Apple's
+// runtime calls. Forwards through to the sx closure with the
+// standard `(__sx_ctx, env, ...args)` shape.
+__block_invoke_void_s32_p :: (block_self: *Block, arg0: s32, arg1: *void) callconv(.c) {
+    typed_fn : (*void, s32, *void) -> void = xx block_self.sx_fn;
+    typed_fn(block_self.sx_env, arg0, arg1);
+}
+
+impl Into(Block) for Closure(s32, *void) -> void {
+    convert :: (self: Closure(s32, *void) -> void) -> Block {
+        .{
+            isa = @_NSConcreteStackBlock,
+            flags = 0,
+            reserved = 0,
+            invoke = xx @__block_invoke_void_s32_p,
+            descriptor = xx @__sx_block_descriptor,
+            sx_env = self.env,
+            sx_fn = self.fn_ptr,
+        };
+    }
+}
+
 // Side-effect capture so we can observe both args reached the
-// closure body, even though void-returning trampolines are the
-// well-tested shape.
+// closure body.
 g_sum: s32 = 0;
 g_tag: *void = null;