feat: honor async-backend with epoll/io_uring, fix last RV13 items

Resolves the 4 P3 items in docs/rewrite/notes/review-rv13-codex.md
(final-Z16.md):
- async-backend now takes effect like Ghostty: ghostty_os::xev ports
  libxev's backend detection (io_uring, then epoll); global init detects
  and logs it, the GTK startup applies the config with Zig's messages,
  and +version reports the real backend. The termio IO loop runs on a
  new reactor with epoll, io_uring (io-uring crate) and poll(2) (kept
  for macOS, where libxev uses kqueue). The 21 exec integration tests
  run under every backend; io_uring was exercised here.
- auto-update-channel defaults to the build's release channel.
- Windows error names: sharing violation -> AccessDenied, plus
  ERROR_FILE_EXISTS -> PathAlreadyExists and virus errors ->
  AntivirusInterference, mirroring std.os.windows.OpenFile's NTSTATUS
  mapping in Zig 0.15.2 (verified against its source by the
  orchestrator).
- Exact ports of std.fs.path.basenameWindows/basenamePosix for theme
  name validation (drive, UNC and device roots).

Test Plan:
- cargo test --workspace --no-fail-fast (3555 passed, exit 0)
- just check-macos (both), just check-windows, just check-wasm
- +show-config --default --docs vs /usr/bin/ghostty (only the
  build-specific gtk-opengl-debug line differs)

crates/ghostty-config/src/theme.rs

@@ -151,24 +151,43 @@ fn check_regular(file: &File, theme: &str, diags: &mut DiagnosticList) -> bool {
     }
 }
 
-/// `std.fs.path.basename` (last `ComponentIterator` component; `.` and `..`
-/// are ordinary names). The caller only passes non-absolute paths, so the root
-/// is empty on POSIX and an optional `X:` drive designator on Windows.
+/// `std.fs.path.basename` for the host: `basenamePosix` or `basenameWindows`.
 fn zig_basename(path: &str) -> &str {
-    let is_sep = |b: u8| b == b'/' || (cfg!(windows) && b == b'\\');
-    let bytes = path.as_bytes();
-    let root_end = if cfg!(windows)
-        && bytes.len() >= 2
-        && bytes[0].is_ascii_alphabetic()
-        && bytes[1] == b':'
-    {
-        2
+    if cfg!(windows) {
+        basename_windows(path)
     } else {
-        0
-    };
+        basename_posix(path)
+    }
+}
+
+/// `std.fs.path.basenamePosix`: the last `ComponentIterator` component.
+/// `.` and `..` are ordinary names.
+fn basename_posix(path: &str) -> &str {
+    let root_len = usize::from(path.as_bytes().first() == Some(&b'/'));
+    basename_inner(path, root_len, |b| b == b'/')
+}
+
+/// `std.fs.path.basenameWindows`.
+fn basename_windows(path: &str) -> &str {
+    basename_inner(path, parse_path_windows_root_len(path), |b| {
+        b == b'/' || b == b'\\'
+    })
+}
+
+/// `ComponentIterator.init` + `last()`: skip the root and any separators after
+/// it, then take the last component (empty if there is none).
+fn basename_inner(path: &str, root_len: usize, is_sep: impl Fn(u8) -> bool) -> &str {
+    let bytes = path.as_bytes();
+    let mut root_end_index = root_len;
+    for &c in &bytes[root_len..] {
+        if !is_sep(c) {
+            break;
+        }
+        root_end_index += 1;
+    }
     let mut end = bytes.len();
     loop {
-        if end == root_end {
+        if end == root_end_index {
             return "";
         }
         if !is_sep(bytes[end - 1]) {
@@ -177,12 +196,73 @@ fn zig_basename(path: &str) -> &str {
         end -= 1;
     }
     let mut start = end;
-    while start != root_end && !is_sep(bytes[start - 1]) {
+    while start != root_end_index && !is_sep(bytes[start - 1]) {
         start -= 1;
     }
     &path[start..end]
 }
 
+/// `std.fs.path.parsePathWindows(u8, path).root.len` (with
+/// `getWin32PathType`; the path is WTF-8 so the drive letter is one whole code
+/// point of at most three bytes, like `RtlDetermineDosPathNameType_U`).
+fn parse_path_windows_root_len(path: &str) -> usize {
+    let b = path.as_bytes();
+    let sep = |c: u8| c == b'/' || c == b'\\';
+    let Some(&first) = b.first() else {
+        return 0; // relative
+    };
+    if sep(first) {
+        // \x
+        if b.len() < 2 || !sep(b[1]) {
+            return 1; // rooted
+        }
+        // \\. or \\?
+        if b.len() > 2 && (b[2] == b'.' || b[2] == b'?') {
+            // exactly \\. or \\? with nothing trailing
+            if b.len() == 3 {
+                return b.len(); // root_local_device
+            }
+            // \\.\x or \\?\x
+            if sep(b[3]) {
+                return 4; // local_device
+            }
+        }
+        // \\x: UNC absolute (`parseUNC`)
+        let Some(server_end) = b[2..].iter().position(|&c| sep(c)).map(|i| i + 2) else {
+            return b.len();
+        };
+        // Any number of separators may sit between the server and the share.
+        let share_start =
+            server_end + 1 + b[server_end + 1..].iter().take_while(|&&c| sep(c)).count();
+        if share_start == b.len() {
+            // No share: the share is the empty slice right after the server
+            // separator.
+            return server_end + 1;
+        }
+        let share_end = b[share_start..]
+            .iter()
+            .position(|&c| sep(c))
+            .map_or(b.len(), |i| i + share_start);
+        // `sep_after_share` adds one more.
+        return share_end + usize::from(share_end != b.len());
+    }
+    // Drive letter: a code point of 1..=3 bytes followed by ':'.
+    let colon_i = match first {
+        0x00..=0x7f => 1,
+        0xc2..=0xdf => 2,
+        0xe0..=0xef => 3,
+        _ => return 0, // invalid or 4-byte sequence: relative
+    };
+    if b.len() < colon_i + 1 || b[colon_i] != b':' {
+        return 0; // relative
+    }
+    if b.len() > colon_i + 1 && sep(b[colon_i + 1]) {
+        colon_i + 2 // drive_absolute
+    } else {
+        colon_i + 1 // drive_relative
+    }
+}
+
 /// Open the given named theme. If there are any errors then messages
 /// will be appended to the given error list and None is returned. If
 /// a Some return value is returned, there are never any errors added.
@@ -363,6 +443,68 @@ mod tests {
         );
     }
 
+    #[test]
+    fn basename_windows_matches_zig_tests() {
+        // The `testBasenameWindows` cases of `std/fs/path.zig`.
+        for (input, expected) in [
+            ("\\dir\\basename.ext", "basename.ext"),
+            ("\\basename.ext", "basename.ext"),
+            ("basename.ext", "basename.ext"),
+            ("basename.ext\\", "basename.ext"),
+            ("basename.ext\\\\", "basename.ext"),
+            ("foo", "foo"),
+            ("C:", ""),
+            ("C:.", "."),
+            ("C:\\", ""),
+            ("C:\\dir\\base.ext", "base.ext"),
+            ("C:\\basename.ext", "basename.ext"),
+            ("C:basename.ext", "basename.ext"),
+            ("C:basename.ext\\", "basename.ext"),
+            ("C:basename.ext\\\\", "basename.ext"),
+            ("\\\\.", ""),
+            ("\\\\.\\", ""),
+            ("\\\\.\\basename.ext", "basename.ext"),
+            ("\\\\?", ""),
+            ("\\\\?\\", ""),
+            ("\\\\?\\basename.ext", "basename.ext"),
+            ("C:foo", "foo"),
+            ("file:stream", "file:stream"),
+            // Non-letter drive designators are drive roots too (the
+            // RV13 finding): `1:theme` is `theme`, not the whole name.
+            ("1:theme", "theme"),
+            ("1:", ""),
+            ("\u{3bb}:theme", "theme"),
+            ("\u{20ac}:\\theme", "theme"),
+            // UNC roots.
+            ("//a", ""),
+            ("//a/b", ""),
+            ("//a/b/c", "c"),
+            ("\\\\server\\\\share\\file", "file"),
+            ("//", ""),
+        ] {
+            assert_eq!(basename_windows(input), expected, "{input:?}");
+        }
+    }
+
+    #[test]
+    fn basename_posix_matches_zig_tests() {
+        for (input, expected) in [
+            ("", ""),
+            ("/", ""),
+            ("/dir/basename.ext", "basename.ext"),
+            ("/basename.ext", "basename.ext"),
+            ("basename.ext/", "basename.ext"),
+            ("basename.ext//", "basename.ext"),
+            ("/aaa/", "aaa"),
+            ("//a", "a"),
+            ("\\dir\\basename.ext", "\\dir\\basename.ext"),
+            ("basename.ext\\\\", "basename.ext\\\\"),
+            ("1:theme", "1:theme"),
+        ] {
+            assert_eq!(basename_posix(input), expected, "{input:?}");
+        }
+    }
+
     #[test]
     fn zig_basename_matches_std() {
         assert_eq!(zig_basename(""), "");