feat(renderer): port the OpenGL backend, shaders and size math

Ports the terminal-independent half of ZIG/src/renderer (OpenGL only):
- opengl/*: buffers, frames, pipelines, render passes, samplers,
  targets, textures and the OpenGL GraphicsAPI backend on top of glow;
  the GTK GLArea glue is replaced by a get_proc_address loader closure
- the GLSL shaders, copied verbatim and embedded; uniform/vertex structs
  as bytemuck Pod types with std140 offsets asserted in tests
- shadertoy custom shaders converted with naga (GLSL in -> validate ->
  GLSL 430 out) instead of glslang + spirv-cross
- size (screen/grid/cell/padding math), cursor style logic, backend
  health, options and message types

The crate opts into unsafe_code = "deny"; unsafe glow calls live only in
opengl/gl.rs. A headless EGL integration test builds every pipeline and
the converted shadertoy shaders on Mesa and reads back rendered pixels.

Note: Zig's shadertoy Uniforms order the selection background/foreground
colors opposite to the GLSL block (likely an upstream bug); kept as in
Zig for parity and recorded in the notes.

Deferred to the next renderer pass: generic, cell, image, link, row,
State, Thread, Overlay (need terminal render state).

Test Plan:
- cargo test -p ghostty-renderer (33 tests incl. tests/egl_headless.rs)

crates/ghostty-renderer/src/opengl/frame.rs

@@ -0,0 +1,66 @@
+//! Wrapper for handling render frames (`opengl/Frame.zig`).
+use std::sync::Arc;
+
+use super::OpenGL;
+use super::render_pass::{Attachment, Options as RenderPassOptions, RenderPass};
+use super::target::Target;
+use crate::backend::Health;
+
+/// Options for beginning a frame.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Options {}
+
+/// A frame being encoded.
+///
+/// Upstream holds `*Renderer` and calls `renderer.frameCompleted(health)`
+/// after presenting; here the frame borrows the graphics API and
+/// [`Frame::complete`] returns the [`Health`] for the renderer to report.
+pub struct Frame<'a> {
+    api: &'a mut OpenGL,
+    target: Arc<Target>,
+}
+
+impl<'a> Frame<'a> {
+    /// Begin encoding a frame.
+    ///
+    /// The target is presented via the provided API when completed.
+    pub fn begin(_opts: Options, api: &'a mut OpenGL, target: Arc<Target>) -> Frame<'a> {
+        Frame { api, target }
+    }
+
+    /// Add a render pass to this frame with the provided attachments.
+    /// Returns a RenderPass which allows render steps to be added.
+    pub fn render_pass<'b>(&self, attachments: &'b [Attachment<'b>]) -> RenderPass<'b> {
+        let gl = self.api.gl().expect("OpenGL context not initialized");
+        RenderPass::begin(gl, RenderPassOptions { attachments })
+    }
+
+    /// Complete this frame and present the target.
+    ///
+    /// If `sync` is true, this will block until the frame is presented.
+    ///
+    /// NOTE: For OpenGL, `sync` is ignored and we always block.
+    pub fn complete(self, _sync: bool) -> Health {
+        let Some(gl) = self.api.gl().cloned() else {
+            return Health::Unhealthy;
+        };
+        gl.finish();
+
+        // If there are any GL errors, consider the frame unhealthy.
+        let health = if gl.get_error().is_ok() {
+            Health::Healthy
+        } else {
+            Health::Unhealthy
+        };
+
+        // If the frame is healthy, present it.
+        if health == Health::Healthy
+            && let Err(err) = self.api.present(&self.target)
+        {
+            log::error!("Failed to present render target: err={err}");
+        }
+
+        // Report the health to the renderer.
+        health
+    }
+}