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-font/src/shaper/noop.rs

@@ -3,10 +3,25 @@
 //! font's glyph index.
 
 use crate::{
-    face::freetype::Face,
-    shape::{self, Cell},
+    face::Face,
+    shape::{self, Cell, TextRun},
+    shared_grid::SharedGrid,
 };
 
+/// Never produced (the no-op shaper can't fail to initialize); exists so the
+/// API matches the other shapers (`shape::ShapeError`).
+#[derive(Debug, thiserror::Error)]
+pub enum ShapeError {}
+
+/// Errors from [`Shaper::shape_run`].
+#[derive(Debug, thiserror::Error)]
+pub enum ShapeRunError {
+    #[error(transparent)]
+    GetFace(#[from] crate::collection::GetFaceError),
+    #[error(transparent)]
+    Shape(#[from] ShapeError),
+}
+
 #[derive(Debug, Clone, Copy)]
 struct Codepoint {
     codepoint: u32,
@@ -24,8 +39,9 @@ pub struct Shaper {
 }
 
 impl Shaper {
-    pub fn new(_opts: &shape::Options) -> Shaper {
-        Shaper::default()
+    #[allow(clippy::unnecessary_wraps)]
+    pub fn new(_opts: &shape::Options) -> Result<Shaper, ShapeError> {
+        Ok(Shaper::default())
     }
 
     pub fn end_frame(&self) {}
@@ -45,6 +61,20 @@ impl Shaper {
 
     pub fn finalize(&mut self) {}
 
+    /// Shape the given text run (looks the face up in `grid`).
+    pub fn shape_run(
+        &mut self,
+        grid: &SharedGrid,
+        run: &TextRun,
+    ) -> Result<&[Cell], ShapeRunError> {
+        if run.font_index.special().is_none() {
+            let mut guard = grid.write();
+            let face = guard.resolver.collection.get_face(run.font_index)?;
+            return Ok(self.shape(Some(face)));
+        }
+        Ok(self.shape(None))
+    }
+
     /// Shape the current run. `face` is `None` for special fonts (sprite),
     /// whose codepoint == glyph index.
     ///
@@ -76,7 +106,7 @@ mod tests {
 
     #[test]
     fn noop_special_passthrough() {
-        let mut s = Shaper::new(&shape::Options::default());
+        let mut s = Shaper::new(&shape::Options::default()).unwrap();
         s.prepare();
         s.add_codepoint(0x41, 0);
         s.add_codepoint(0x42, 2);