feat(core): port App/Surface and wire up the runnable ghostty binary

This is the integration step that turns the ported crates into a working
terminal: `cargo run` now opens a GTK window running the user's shell.

ghostty-core ports App.zig, Surface.zig (split into keyboard, mouse,
binding, clipboard and config submodules), surface_mouse.zig and
global.zig, and implements the runtime traits. perform_binding_action
handles every binding action.

Cross-crate integration:
- The core<->runtime traits (CoreApp, CoreSurface, RtApp, RtSurface,
  Waker) move from apprt-gtk into ghostty_apprt::runtime_api so the core
  stays runtime-agnostic; Scrollbar/RendererHealth stand-ins are replaced
  by the real terminal/renderer types.
- termio now uses ghostty_renderer::state::{State, SharedState}; the
  renderer calls kitty_update; image-storage-limit is applied at init
  and on config change.
- The search thread locks the terminal through a TerminalLock trait so
  it can share the render state mutex; termio's Wakeup gained a hook to
  wake the renderer thread.
- apprt-gtk: GL proc addresses are resolved through libepoxy's
  epoxy_glFoo pointer variables (plain glFoo symbols resolved to null),
  default DPI fixed to 96, libadwaita version read without GTK init so
  --version works headless.

The root binary dispatches +actions to ghostty-cli (list-fonts,
show-face and new-window are now wired) and otherwise runs the GTK app
with the real core.

Verified at runtime on Wayland and X11: shell prompt and colored output
render, child exit closes the window cleanly. Not yet verified: keyboard
and mouse input, clipboard, IME, tabs and splits (no key injection was
possible in this environment). GHOSTTY_DEBUG_SCREENSHOT=<png> dumps the
renderer's last frame for headless checks.

Test Plan:
- cargo test --workspace (2890 passed)
- cargo clippy --workspace --all-targets -- -D warnings
- GSETTINGS_BACKEND=memory GHOSTTY_RESOURCES_DIR=/usr/share/ghostty \
  cargo run

crates/ghostty-termio/src/wakeup.rs

@@ -12,17 +12,35 @@ use std::sync::Arc;
 use rustix::event::{EventfdFlags, eventfd};
 
 /// See the module docs. Cloning shares the same underlying eventfd.
-#[derive(Clone, Debug)]
-pub struct Wakeup(Arc<OwnedFd>);
+#[derive(Clone)]
+pub struct Wakeup(Arc<OwnedFd>, Option<Arc<dyn Fn() + Send + Sync>>);
+
+impl std::fmt::Debug for Wakeup {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Wakeup").field(&self.0).finish()
+    }
+}
 
 impl Wakeup {
     pub fn new() -> io::Result<Wakeup> {
         let fd = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
-        Ok(Wakeup(Arc::new(fd)))
+        Ok(Wakeup(Arc::new(fd), None))
+    }
+
+    /// A wakeup that calls `hook` instead of signalling an eventfd. Used to
+    /// bridge into waiters that are not `poll(2)`-based (the renderer
+    /// thread's channel). `as_fd`/`drain` are meaningless for these.
+    pub fn with_hook(hook: Arc<dyn Fn() + Send + Sync>) -> io::Result<Wakeup> {
+        let fd = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
+        Ok(Wakeup(Arc::new(fd), Some(hook)))
     }
 
     /// Wake up the waiter. Multiple notifications coalesce.
     pub fn notify(&self) -> io::Result<()> {
+        if let Some(hook) = &self.1 {
+            hook();
+            return Ok(());
+        }
         loop {
             match rustix::io::write(&*self.0, &1u64.to_ne_bytes()) {
                 Ok(_) => return Ok(()),