feat(macos): port Ghostty's macOS code paths (Metal, CoreText, Darwin)

Ports the macOS-specific Zig code behind cfg(target_os = "macos"):
- renderer: a GraphicsApi trait with generic::Renderer<G>; Metal backend
  (all renderer/metal/* files, shaders.metal verbatim, runtime library
  compile, IOSurface layer, CVDisplayLink), shadertoy -> MSL via naga;
  OpenGL remains the backend elsewhere.
- font: CoreText face, shaper and discovery with build.rs backend
  selection (coretext default; coretext-freetype / coretext-harfbuzz /
  coretext-noshape features), no fontconfig/freetype/harfbuzz on Apple.
- input: KeymapDarwin via UCKeyTranslate, option-as-alt, mac keycodes.
- os: macos, mach, cf_release_thread, NSProcessInfo args and macOS
  branches; config: macOS defaults, keybinds, Application Support paths.
- termio/core: login(1) wrapping, openpty/execvpe, Darwin child exit
  handling, os_log logging.

Compile-checked for aarch64/x86_64-apple-darwin (clippy -D warnings
clean) using the cross setup in docs/rewrite/notes/macos-M1.md; cannot
run here. The embedded runtime/C API (embedded.zig) is the next step.

Also includes the cross-platform integration edits shared by the crash,
verification, Windows and macOS work (Cargo target-gating, thread
crash-context hooks, apprt-gtk surface/IME refactor, termio/os cfg
gates), a cfg fix so ghostty-config builds on wasm32, and an allow for
the intentional recursion in the crash overflow test.

Test Plan:
- cargo test --workspace (3224 passed)
- cargo clippy --workspace --all-targets -- -D warnings
- cargo check --target aarch64-apple-darwin -p ghostty-renderer (with
  the documented cross env)

crates/ghostty-core/src/surface/keyboard.rs

@@ -906,6 +906,33 @@ impl Surface {
         }
     }
 
+    /// Build the key encoding options (Zig: `encodeKeyOpts`). On macOS the
+    /// `macos-option-as-alt` value comes from the config, or is detected from
+    /// the keyboard layout when unset.
+    fn encode_key_opts(&self) -> key_encode::Options {
+        let mut opts = {
+            let t = self.lock_terminal();
+            encode_options_from_terminal(&t)
+        };
+        if !cfg!(target_os = "macos") {
+            return opts;
+        }
+
+        opts.macos_option_as_alt = self.cfg().macos_option_as_alt.unwrap_or_else(|| {
+            // If we don't have alt pressed, it doesn't matter what this
+            // config is so we can just say "false" and avoid more expensive
+            // checks below.
+            if !self.mouse.borrow().mods.alt {
+                return ghostty_input::OptionAsAlt::False;
+            }
+
+            // Alt is pressed, we're on macOS. We break some encapsulation
+            // here and assume libghostty for ease...
+            self.rt_app.keyboard_layout().detect_option_as_alt()
+        });
+        opts
+    }
+
     /// Encodes the key event into a write request. Returns `None` if
     /// nothing was encoded.
     fn encode_key(
@@ -914,10 +941,7 @@ impl Surface {
         insp_ev: Option<&mut inspector::KeyEvent>,
     ) -> Option<IoMessage> {
         // Build our encoding options, which requires the lock.
-        let opts = {
-            let t = self.lock_terminal();
-            encode_options_from_terminal(&t)
-        };
+        let opts = self.encode_key_opts();
 
         let mut data: Vec<u8> = Vec::with_capacity(64);
         if let Err(err) = key_encode::encode(&mut data, event, &opts) {