feat(apprt-gtk): port the GTK4/libadwaita app runtime

Ports ZIG/src/apprt/gtk into ghostty-apprt-gtk: every GObject class
(application, window, tab, split tree, surface + scrolled window,
child-exited banner, search/key-state/resize overlays, command palette,
global shortcuts, all dialogs, config wrapper) as glib subclasses with
the same GType names, properties, signals and template children; GDK
key translation; X11 and Wayland window-protocol helpers (blur, CSD,
quick terminal via gtk4-layer-shell); single-instance D-Bus IPC;
gsettings; cgroup scope creation.

build.rs compiles Ghostty's blueprints with blueprint-compiler and
bundles UI, CSS and icons into a gresource, as Ghostty's build does.

The core is not ported yet, so the crate defines the boundary it needs
in src/core.rs (CoreApp, CoreSurface, RtApp, RtSurface, Waker); the
spec is in docs/rewrite/notes/ghostty-apprt-gtk.md. ghostty-core will
implement these traits (the crate no longer depends on core to avoid a
cycle). examples/demo.rs runs the app with a dummy core that clears the
GLArea; it launches on Wayland without GTK criticals.

Stubs/open items: toggle_visibility, float_window, secure_input and
close_all_windows return false; inspector is a no-op; X11/Wayland
protocol code is untested against real compositors; gtk4-rs doesn't
expose the GLArea framebuffer id, so the renderer must query it.

Also registers ghostty-apprt and ghostty-cli in workspace.dependencies.

Test Plan:
- cargo test -p ghostty-apprt-gtk (36 tests)
- DEMO_QUIT_AFTER_MS=3000 cargo run -p ghostty-apprt-gtk --example demo

crates/ghostty-apprt-gtk/src/class/dialog.rs

@@ -0,0 +1,64 @@
+//! Port of apprt/gtk/class/dialog.zig (`GhosttyDialog`).
+//!
+//! Thin `adw::AlertDialog` subclass (we require libadwaita >= 1.5 so the
+//! `adw::MessageDialog` fallback is not needed). Subclasses implement
+//! [`DialogImpl`] and may override `response` via `AlertDialogImpl`.
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use gtk::glib;
+
+mod imp {
+    use adw::subclass::prelude::*;
+    use gtk::glib;
+
+    #[derive(Default)]
+    pub struct Dialog;
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for Dialog {
+        const NAME: &'static str = "GhosttyDialog";
+        type Type = super::Dialog;
+        type ParentType = adw::AlertDialog;
+    }
+
+    impl ObjectImpl for Dialog {}
+    impl WidgetImpl for Dialog {}
+    impl AdwDialogImpl for Dialog {}
+    impl AdwAlertDialogImpl for Dialog {}
+}
+
+glib::wrapper! {
+    pub struct Dialog(ObjectSubclass<imp::Dialog>)
+        @extends adw::AlertDialog, adw::Dialog, gtk::Widget,
+        @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::ShortcutManager;
+}
+
+/// Implemented by subclasses of [`Dialog`].
+pub trait DialogImpl: AdwAlertDialogImpl {}
+
+#[allow(unsafe_code)]
+// SAFETY: `Dialog` adds no class/instance data of its own; we simply forward
+// to the parent (`adw::AlertDialog`) class/instance initialization, which is
+// valid for any `T: DialogImpl` (a subtype of `AdwAlertDialogImpl`).
+unsafe impl<T: DialogImpl> IsSubclassable<T> for Dialog {
+    fn class_init(class: &mut glib::Class<Self>) {
+        <adw::AlertDialog as IsSubclassable<T>>::class_init(class.upcast_ref_mut());
+    }
+
+    fn instance_init(instance: &mut glib::subclass::InitializingObject<T>) {
+        <adw::AlertDialog as IsSubclassable<T>>::instance_init(instance);
+    }
+}
+
+impl Dialog {
+    /// Present the dialog over `parent`.
+    pub fn present(&self, parent: Option<&impl IsA<gtk::Widget>>) {
+        adw::prelude::AdwDialogExt::present(self, parent);
+    }
+
+    /// Close the dialog without emitting `close-attempt`.
+    pub fn close(&self) {
+        self.force_close();
+    }
+}