feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

12 files changed, 0 insertions, 954 deletions

diff --git a/vendor/rustix/src/maybe_polyfill/no_std/io/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/io/mod.rs
deleted file mode 100644
index f0ad7504..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/io/mod.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/sys/unix/io.rs
-//! dca3f1b786efd27be3b325ed1e01e247aa589c3b.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-
-#![allow(unsafe_code)]
-use crate::backend::c;
-#[cfg(not(linux_raw))]
-use c::size_t as __kernel_size_t;
-use core::marker::PhantomData;
-use core::slice;
-#[cfg(linux_raw)]
-use linux_raw_sys::general::__kernel_size_t;
-
-/// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html>
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct IoSlice<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a [u8]>,
-}
-
-impl<'a> IoSlice<'a> {
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.new>
-    #[inline]
-    pub fn new(buf: &'a [u8]) -> IoSlice<'a> {
-        IoSlice {
-            vec: c::iovec {
-                iov_base: buf.as_ptr() as *mut u8 as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _p: PhantomData,
-        }
-    }
-
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.advance>
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n as _ {
-            panic!("advancing IoSlice beyond its length");
-        }
-
-        unsafe {
-            // `__kernel_size_t` will always have the same size as `usize`, but it is a `u32` on
-            // 32-bit platforms and `u64` on 64-bit platforms when using `linux_raw` backend
-            self.vec.iov_len -= n as __kernel_size_t;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSlice.html#method.as_slice>
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len as usize) }
-    }
-}
-
-/// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html>
-#[repr(transparent)]
-pub struct IoSliceMut<'a> {
-    vec: c::iovec,
-    _p: PhantomData<&'a mut [u8]>,
-}
-
-impl<'a> IoSliceMut<'a> {
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.new>
-    #[inline]
-    pub fn new(buf: &'a mut [u8]) -> IoSliceMut<'a> {
-        IoSliceMut {
-            vec: c::iovec {
-                iov_base: buf.as_mut_ptr() as *mut c::c_void,
-                iov_len: buf.len() as _,
-            },
-            _p: PhantomData,
-        }
-    }
-
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.advance>
-    #[inline]
-    pub fn advance(&mut self, n: usize) {
-        if self.vec.iov_len < n as _ {
-            panic!("advancing IoSliceMut beyond its length");
-        }
-
-        unsafe {
-            // `__kernel_size_t` will always have the same size as `usize`, but it is a `u32` on
-            // 32-bit platforms and `u64` on 64-bit platforms when using `linux_raw` backend
-            self.vec.iov_len -= n as __kernel_size_t;
-            self.vec.iov_base = self.vec.iov_base.add(n);
-        }
-    }
-
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.as_slice>
-    #[inline]
-    pub fn as_slice(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.vec.iov_base as *mut u8, self.vec.iov_len as usize) }
-    }
-
-    /// <https://doc.rust-lang.org/stable/std/io/struct.IoSliceMut.html#method.as_slice_mut>
-    #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut [u8] {
-        unsafe {
-            slice::from_raw_parts_mut(self.vec.iov_base as *mut u8, self.vec.iov_len as usize)
-        }
-    }
-}
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/mod.rs
deleted file mode 100644
index f29d4c34..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/mod.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//! Polyfill of parts of the standard library for `no_std` builds.
-//!
-//! All code in this subtree is derived from the standard library and licensed
-//! MIT or Apache 2.0 at your option.
-//!
-//! This implementation is used when `std` is not available and polyfills the
-//! necessary items from `std`. When the `std` feature is specified (so the
-//! standard library is available), the file `src/polyfill/std` is used
-//! instead, which just imports the respective items from `std`.
-
-#[cfg(not(windows))]
-pub mod io;
-#[cfg(not(target_os = "wasi"))]
-#[cfg(feature = "net")]
-pub mod net;
-pub mod os;
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/net/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/net/mod.rs
deleted file mode 100644
index bff56b13..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/net/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-#[allow(unused_imports)]
-pub use core::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/fd/mod.rs
deleted file mode 100644
index ea559534..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/mod.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/fd/mod.rs at revision
-//! fa68e73e9947be8ffc5b3b46d899e4953a44e7e9.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-//!
-//! Owned and borrowed Unix-like file descriptors.
-//!
-//! This module is supported on Unix platforms and WASI, which both use a
-//! similar file descriptor system for referencing OS resources.
-
-#![cfg_attr(staged_api, stable(feature = "os_fd", since = "1.66.0"))]
-#![deny(unsafe_op_in_unsafe_fn)]
-
-// `RawFd`, `AsRawFd`, etc.
-mod raw;
-
-// `OwnedFd`, `AsFd`, etc.
-mod owned;
-
-// Export the types and traits for the public API.
-#[cfg_attr(staged_api, stable(feature = "os_fd", since = "1.66.0"))]
-pub use owned::*;
-#[cfg_attr(staged_api, stable(feature = "os_fd", since = "1.66.0"))]
-pub use raw::*;
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/owned.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/fd/owned.rs
deleted file mode 100644
index b6aea61a..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/owned.rs
+++ /dev/null
@@ -1,301 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/fd/owned.rs at revision
-//! 334a54cd83191f38ad8046ed94c45de735c86c65.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-//!
-//! Owned and borrowed Unix-like file descriptors.
-
-#![cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-#![deny(unsafe_op_in_unsafe_fn)]
-#![allow(unsafe_code)]
-
-use super::raw::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
-use crate::io::close;
-use core::fmt;
-use core::marker::PhantomData;
-use core::mem::forget;
-
-/// A borrowed file descriptor.
-///
-/// This has a lifetime parameter to tie it to the lifetime of something that owns the file
-/// descriptor. For the duration of that lifetime, it is guaranteed that nobody will close the file
-/// descriptor.
-///
-/// This uses `repr(transparent)` and has the representation of a host file
-/// descriptor, so it can be used in FFI in places where a file descriptor is
-/// passed as an argument, it is not captured or consumed, and it never has the
-/// value `-1`.
-///
-/// This type does not have a [`ToOwned`][crate::borrow::ToOwned]
-/// implementation. Calling `.to_owned()` on a variable of this type will call
-/// it on `&BorrowedFd` and use `Clone::clone()` like `ToOwned` does for all
-/// types implementing `Clone`. The result will be descriptor borrowed under
-/// the same lifetime.
-///
-/// To obtain an [`OwnedFd`], you can use [`BorrowedFd::try_clone_to_owned`]
-/// instead, but this is not supported on all platforms.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_start(0))]
-// libstd/os/raw/mod.rs assures me that every libstd-supported platform has a
-// 32-bit c_int. Below is -2, in two's complement, but that only works out
-// because c_int is 32 bits.
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE))]
-#[cfg_attr(rustc_attrs, rustc_nonnull_optimization_guaranteed)]
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-pub struct BorrowedFd<'fd> {
-    fd: RawFd,
-    _phantom: PhantomData<&'fd OwnedFd>,
-}
-
-/// An owned file descriptor.
-///
-/// This closes the file descriptor on drop. It is guaranteed that nobody else will close the file
-/// descriptor.
-///
-/// This uses `repr(transparent)` and has the representation of a host file
-/// descriptor, so it can be used in FFI in places where a file descriptor is
-/// passed as a consumed argument or returned as an owned value, and it never
-/// has the value `-1`.
-///
-/// You can use [`AsFd::as_fd`] to obtain a [`BorrowedFd`].
-#[repr(transparent)]
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_start(0))]
-// libstd/os/raw/mod.rs assures me that every libstd-supported platform has a
-// 32-bit c_int. Below is -2, in two's complement, but that only works out
-// because c_int is 32 bits.
-#[cfg_attr(rustc_attrs, rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE))]
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-#[cfg_attr(rustc_attrs, rustc_nonnull_optimization_guaranteed)]
-pub struct OwnedFd {
-    fd: RawFd,
-}
-
-impl BorrowedFd<'_> {
-    /// Returns a `BorrowedFd` holding the given raw file descriptor.
-    ///
-    /// # Safety
-    ///
-    /// The resource pointed to by `fd` must remain open for the duration of
-    /// the returned `BorrowedFd`, and it must not have the value `-1`.
-    #[inline]
-    #[cfg_attr(
-        staged_api,
-        rustc_const_stable(feature = "io_safety", since = "1.63.0")
-    )]
-    #[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-    pub const unsafe fn borrow_raw(fd: RawFd) -> Self {
-        assert!(fd != u32::MAX as RawFd);
-        // SAFETY: we just asserted that the value is in the valid range and isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
-        #[allow(unused_unsafe)]
-        unsafe {
-            Self {
-                fd,
-                _phantom: PhantomData,
-            }
-        }
-    }
-}
-
-impl OwnedFd {
-    /// Creates a new `OwnedFd` instance that shares the same underlying file handle
-    /// as the existing `OwnedFd` instance.
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn try_clone(&self) -> crate::io::Result<Self> {
-        // We want to atomically duplicate this file descriptor and set the
-        // CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This
-        // is a POSIX flag that was added to Linux in 2.6.24.
-        #[cfg(not(target_os = "espidf"))]
-        let fd = crate::io::fcntl_dupfd_cloexec(self, 0)?;
-
-        // For ESP-IDF, F_DUPFD is used instead, because the CLOEXEC semantics
-        // will never be supported, as this is a bare metal framework with
-        // no capabilities for multi-process execution. While F_DUPFD is also
-        // not supported yet, it might be (currently it returns ENOSYS).
-        #[cfg(target_os = "espidf")]
-        let fd = crate::io::fcntl_dupfd(self, 0)?;
-
-        Ok(fd.into())
-    }
-
-    /// Creates a new `OwnedFd` instance that shares the same underlying file handle
-    /// as the existing `OwnedFd` instance.
-    #[cfg(target_arch = "wasm32")]
-    pub fn try_clone(&self) -> crate::io::Result<Self> {
-        Err(crate::io::Errno::NOSYS)
-    }
-}
-
-impl BorrowedFd<'_> {
-    /// Creates a new `OwnedFd` instance that shares the same underlying file
-    /// description as the existing `BorrowedFd` instance.
-    #[cfg(not(any(target_arch = "wasm32", target_os = "hermit")))]
-    #[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
-        // Avoid using file descriptors below 3 as they are used for stdio
-
-        // We want to atomically duplicate this file descriptor and set the
-        // CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This
-        // is a POSIX flag that was added to Linux in 2.6.24.
-        #[cfg(not(target_os = "espidf"))]
-        let fd = crate::io::fcntl_dupfd_cloexec(self, 3)?;
-
-        // For ESP-IDF, F_DUPFD is used instead, because the CLOEXEC semantics
-        // will never be supported, as this is a bare metal framework with
-        // no capabilities for multi-process execution. While F_DUPFD is also
-        // not supported yet, it might be (currently it returns ENOSYS).
-        #[cfg(target_os = "espidf")]
-        let fd = crate::io::fcntl_dupfd(self, 3)?;
-
-        Ok(fd)
-    }
-
-    /// Creates a new `OwnedFd` instance that shares the same underlying file
-    /// description as the existing `BorrowedFd` instance.
-    #[cfg(any(target_arch = "wasm32", target_os = "hermit"))]
-    #[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-    pub fn try_clone_to_owned(&self) -> crate::io::Result<OwnedFd> {
-        Err(crate::io::Errno::NOSYS)
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl AsRawFd for BorrowedFd<'_> {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        self.fd
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl AsRawFd for OwnedFd {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        self.fd
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl IntoRawFd for OwnedFd {
-    #[inline]
-    fn into_raw_fd(self) -> RawFd {
-        let fd = self.fd;
-        forget(self);
-        fd
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl FromRawFd for OwnedFd {
-    /// Constructs a new instance of `Self` from the given raw file descriptor.
-    ///
-    /// # Safety
-    ///
-    /// The resource pointed to by `fd` must be open and suitable for assuming
-    /// [ownership][io-safety]. The resource must not require any cleanup other than `close`.
-    ///
-    /// [io-safety]: io#io-safety
-    #[inline]
-    unsafe fn from_raw_fd(fd: RawFd) -> Self {
-        assert_ne!(fd, u32::MAX as RawFd);
-        // SAFETY: we just asserted that the value is in the valid range and isn't `-1` (the only value bigger than `0xFF_FF_FF_FE` unsigned)
-        #[allow(unused_unsafe)]
-        unsafe {
-            Self { fd }
-        }
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl Drop for OwnedFd {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            // Errors are ignored when closing a file descriptor. The reason
-            // for this is that if an error occurs we don't actually know if
-            // the file descriptor was closed or not, and if we retried (for
-            // something like EINTR), we might close another valid file
-            // descriptor opened after we closed ours.
-            close(self.fd as _);
-        }
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl fmt::Debug for BorrowedFd<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BorrowedFd").field("fd", &self.fd).finish()
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl fmt::Debug for OwnedFd {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnedFd").field("fd", &self.fd).finish()
-    }
-}
-
-/// A trait to borrow the file descriptor from an underlying object.
-///
-/// This is only available on unix platforms and must be imported in order to
-/// call the method. Windows platforms have a corresponding `AsHandle` and
-/// `AsSocket` set of traits.
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-pub trait AsFd {
-    /// Borrows the file descriptor.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// # #![feature(io_safety)]
-    /// use std::fs::File;
-    /// # use std::io;
-    /// # #[cfg(target_os = "wasi")]
-    /// # use std::os::wasi::io::{AsFd, BorrowedFd};
-    /// # #[cfg(unix)]
-    /// # use std::os::unix::io::{AsFd, BorrowedFd};
-    ///
-    /// let mut f = File::open("foo.txt")?;
-    /// # #[cfg(any(unix, target_os = "wasi"))]
-    /// let borrowed_fd: BorrowedFd<'_> = f.as_fd();
-    /// # Ok::<(), io::Error>(())
-    /// ```
-    #[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-    fn as_fd(&self) -> BorrowedFd<'_>;
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl<T: AsFd> AsFd for &T {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        T::as_fd(self)
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl<T: AsFd> AsFd for &mut T {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        T::as_fd(self)
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl AsFd for BorrowedFd<'_> {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        *self
-    }
-}
-
-#[cfg_attr(staged_api, unstable(feature = "io_safety", issue = "87074"))]
-impl AsFd for OwnedFd {
-    #[inline]
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        // SAFETY: `OwnedFd` and `BorrowedFd` have the same validity
-        // invariants, and the `BorrowedFd` is bounded by the lifetime
-        // of `&self`.
-        unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
-    }
-}
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/raw.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/fd/raw.rs
deleted file mode 100644
index 8f6b75ae..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/fd/raw.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/fd/raw.rs at revision
-//! 334a54cd83191f38ad8046ed94c45de735c86c65.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-//!
-//! Raw Unix-like file descriptors.
-
-#![cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-#![allow(unsafe_code)]
-
-use crate::backend::c;
-
-/// Raw file descriptors.
-#[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-pub type RawFd = c::c_int;
-
-/// A trait to extract the raw file descriptor from an underlying object.
-///
-/// This is only available on unix and WASI platforms and must be imported in
-/// order to call the method. Windows platforms have a corresponding
-/// `AsRawHandle` and `AsRawSocket` set of traits.
-#[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-pub trait AsRawFd {
-    /// Extracts the raw file descriptor.
-    ///
-    /// This function is typically used to **borrow** an owned file descriptor.
-    /// When used in this way, this method does **not** pass ownership of the
-    /// raw file descriptor to the caller, and the file descriptor is only
-    /// guaranteed to be valid while the original object has not yet been
-    /// destroyed.
-    ///
-    /// However, borrowing is not strictly required. See [`AsFd::as_fd`]
-    /// for an API which strictly borrows a file descriptor.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use std::fs::File;
-    /// # use std::io;
-    /// #[cfg(unix)]
-    /// use std::os::unix::io::{AsRawFd, RawFd};
-    /// #[cfg(target_os = "wasi")]
-    /// use std::os::wasi::io::{AsRawFd, RawFd};
-    ///
-    /// let mut f = File::open("foo.txt")?;
-    /// // `raw_fd` is only valid as long as `f` exists.
-    /// #[cfg(any(unix, target_os = "wasi"))]
-    /// let raw_fd: RawFd = f.as_raw_fd();
-    /// # Ok::<(), io::Error>(())
-    /// ```
-    #[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-    fn as_raw_fd(&self) -> RawFd;
-}
-
-/// A trait to express the ability to construct an object from a raw file
-/// descriptor.
-#[cfg_attr(staged_api, stable(feature = "from_raw_os", since = "1.1.0"))]
-pub trait FromRawFd {
-    /// Constructs a new instance of `Self` from the given raw file
-    /// descriptor.
-    ///
-    /// This function is typically used to **consume ownership** of the
-    /// specified file descriptor. When used in this way, the returned object
-    /// will take responsibility for closing it when the object goes out of
-    /// scope.
-    ///
-    /// However, consuming ownership is not strictly required. Use a
-    /// [`From<OwnedFd>::from`] implementation for an API which strictly
-    /// consumes ownership.
-    ///
-    /// # Safety
-    ///
-    /// The `fd` passed in must be an [owned file descriptor][io-safety];
-    /// in particular, it must be open.
-    ///
-    /// [io-safety]: io#io-safety
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use std::fs::File;
-    /// # use std::io;
-    /// #[cfg(unix)]
-    /// use std::os::unix::io::{FromRawFd, IntoRawFd, RawFd};
-    /// #[cfg(target_os = "wasi")]
-    /// use std::os::wasi::io::{FromRawFd, IntoRawFd, RawFd};
-    ///
-    /// let f = File::open("foo.txt")?;
-    /// # #[cfg(any(unix, target_os = "wasi"))]
-    /// let raw_fd: RawFd = f.into_raw_fd();
-    /// // SAFETY: no other functions should call `from_raw_fd`, so there
-    /// // is only one owner for the file descriptor.
-    /// # #[cfg(any(unix, target_os = "wasi"))]
-    /// let f = unsafe { File::from_raw_fd(raw_fd) };
-    /// # Ok::<(), io::Error>(())
-    /// ```
-    #[cfg_attr(staged_api, stable(feature = "from_raw_os", since = "1.1.0"))]
-    unsafe fn from_raw_fd(fd: RawFd) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw file descriptor.
-#[cfg_attr(staged_api, stable(feature = "into_raw_os", since = "1.4.0"))]
-pub trait IntoRawFd {
-    /// Consumes this object, returning the raw underlying file descriptor.
-    ///
-    /// This function is typically used to **transfer ownership** of the underlying
-    /// file descriptor to the caller. When used in this way, callers are then the unique
-    /// owners of the file descriptor and must close it once it's no longer needed.
-    ///
-    /// However, transferring ownership is not strictly required. Use a
-    /// [`Into<OwnedFd>::into`] implementation for an API which strictly
-    /// transfers ownership.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use std::fs::File;
-    /// # use std::io;
-    /// #[cfg(unix)]
-    /// use std::os::unix::io::{IntoRawFd, RawFd};
-    /// #[cfg(target_os = "wasi")]
-    /// use std::os::wasi::io::{IntoRawFd, RawFd};
-    ///
-    /// let f = File::open("foo.txt")?;
-    /// #[cfg(any(unix, target_os = "wasi"))]
-    /// let raw_fd: RawFd = f.into_raw_fd();
-    /// # Ok::<(), io::Error>(())
-    /// ```
-    #[cfg_attr(staged_api, stable(feature = "into_raw_os", since = "1.4.0"))]
-    fn into_raw_fd(self) -> RawFd;
-}
-
-#[cfg_attr(
-    staged_api,
-    stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")
-)]
-impl AsRawFd for RawFd {
-    #[inline]
-    fn as_raw_fd(&self) -> RawFd {
-        *self
-    }
-}
-#[cfg_attr(
-    staged_api,
-    stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")
-)]
-impl IntoRawFd for RawFd {
-    #[inline]
-    fn into_raw_fd(self) -> RawFd {
-        self
-    }
-}
-#[cfg_attr(
-    staged_api,
-    stable(feature = "raw_fd_reflexive_traits", since = "1.48.0")
-)]
-impl FromRawFd for RawFd {
-    #[inline]
-    unsafe fn from_raw_fd(fd: RawFd) -> RawFd {
-        fd
-    }
-}
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/mod.rs
deleted file mode 100644
index 67f41f5b..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#[cfg(any(unix, target_os = "wasi"))]
-pub mod fd;
-#[cfg(windows)]
-pub mod windows;
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/mod.rs
deleted file mode 100644
index 77abd03c..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod raw;
-mod socket;
-
-pub use raw::{AsRawSocket, FromRawSocket, IntoRawSocket, RawSocket};
-pub use socket::{AsSocket, BorrowedSocket, OwnedSocket};
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/raw.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/raw.rs
deleted file mode 100644
index 63edf7f6..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/raw.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/windows/io/raw.rs
-//! at revision
-//! 4f9b394c8a24803e57ba892fa00e539742ebafc0.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-
-use super::super::raw;
-
-/// Raw SOCKETs.
-#[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-pub type RawSocket = raw::SOCKET;
-
-/// Extracts raw sockets.
-#[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-pub trait AsRawSocket {
-    /// Extracts the raw socket.
-    ///
-    /// This function is typically used to **borrow** an owned socket.
-    /// When used in this way, this method does **not** pass ownership of the
-    /// raw socket to the caller, and the socket is only guaranteed
-    /// to be valid while the original object has not yet been destroyed.
-    ///
-    /// However, borrowing is not strictly required. See [`AsSocket::as_socket`]
-    /// for an API which strictly borrows a socket.
-    #[cfg_attr(staged_api, stable(feature = "rust1", since = "1.0.0"))]
-    fn as_raw_socket(&self) -> RawSocket;
-}
-
-/// Creates I/O objects from raw sockets.
-#[cfg_attr(staged_api, stable(feature = "from_raw_os", since = "1.1.0"))]
-pub trait FromRawSocket {
-    /// Constructs a new I/O object from the specified raw socket.
-    ///
-    /// This function is typically used to **consume ownership** of the socket
-    /// given, passing responsibility for closing the socket to the returned
-    /// object. When used in this way, the returned object
-    /// will take responsibility for closing it when the object goes out of
-    /// scope.
-    ///
-    /// However, consuming ownership is not strictly required. Use a
-    /// `From<OwnedSocket>::from` implementation for an API which strictly
-    /// consumes ownership.
-    ///
-    /// # Safety
-    ///
-    /// The `socket` passed in must:
-    ///   - be an [owned socket][io-safety]; in particular, it must be open.
-    ///   - be a socket that may be freed via [`closesocket`].
-    ///
-    /// [`closesocket`]: https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-closesocket
-    /// [io-safety]: io#io-safety
-    #[cfg_attr(staged_api, stable(feature = "from_raw_os", since = "1.1.0"))]
-    unsafe fn from_raw_socket(sock: RawSocket) -> Self;
-}
-
-/// A trait to express the ability to consume an object and acquire ownership of
-/// its raw `SOCKET`.
-#[cfg_attr(staged_api, stable(feature = "into_raw_os", since = "1.4.0"))]
-pub trait IntoRawSocket {
-    /// Consumes this object, returning the raw underlying socket.
-    ///
-    /// This function is typically used to **transfer ownership** of the underlying
-    /// socket to the caller. When used in this way, callers are then the unique
-    /// owners of the socket and must close it once it's no longer needed.
-    ///
-    /// However, transferring ownership is not strictly required. Use a
-    /// `Into<OwnedSocket>::into` implementation for an API which strictly
-    /// transfers ownership.
-    #[cfg_attr(staged_api, stable(feature = "into_raw_os", since = "1.4.0"))]
-    fn into_raw_socket(self) -> RawSocket;
-}
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/socket.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/socket.rs
deleted file mode 100644
index 87692b37..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/io/socket.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/windows/io/socket.rs
-//! at revision
-//! 4f9b394c8a24803e57ba892fa00e539742ebafc0.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-
-use super::raw::*;
-use crate::backend::c;
-use core::fmt;
-use core::marker::PhantomData;
-use core::mem::forget;
-
-/// A borrowed socket.
-///
-/// This has a lifetime parameter to tie it to the lifetime of something that
-/// owns the socket.
-///
-/// This uses `repr(transparent)` and has the representation of a host socket,
-/// so it can be used in FFI in places where a socket is passed as an argument,
-/// it is not captured or consumed, and it never has the value
-/// `INVALID_SOCKET`.
-///
-/// This type's `.to_owned()` implementation returns another `BorrowedSocket`
-/// rather than an `OwnedSocket`. It just makes a trivial copy of the raw
-/// socket, which is then borrowed under the same lifetime.
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-#[cfg_attr(staged_api, rustc_layout_scalar_valid_range_start(0))]
-// This is -2, in two's complement. -1 is `INVALID_SOCKET`.
-#[cfg_attr(
-    all(staged_api, target_pointer_width = "32"),
-    rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)
-)]
-#[cfg_attr(
-    all(staged_api, target_pointer_width = "64"),
-    rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FF_FF_FF_FF_FE)
-)]
-#[cfg_attr(staged_api, rustc_nonnull_optimization_guaranteed)]
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-pub struct BorrowedSocket<'socket> {
-    socket: RawSocket,
-    _phantom: PhantomData<&'socket OwnedSocket>,
-}
-
-/// An owned socket.
-///
-/// This closes the socket on drop.
-///
-/// This uses `repr(transparent)` and has the representation of a host socket,
-/// so it can be used in FFI in places where a socket is passed as a consumed
-/// argument or returned as an owned value, and it never has the value
-/// `INVALID_SOCKET`.
-#[repr(transparent)]
-#[cfg_attr(staged_api, rustc_layout_scalar_valid_range_start(0))]
-// This is -2, in two's complement. -1 is `INVALID_SOCKET`.
-#[cfg_attr(
-    all(staged_api, target_pointer_width = "32"),
-    rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FE)
-)]
-#[cfg_attr(
-    all(staged_api, target_pointer_width = "64"),
-    rustc_layout_scalar_valid_range_end(0xFF_FF_FF_FF_FF_FF_FF_FE)
-)]
-#[cfg_attr(staged_api, rustc_nonnull_optimization_guaranteed)]
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-pub struct OwnedSocket {
-    socket: RawSocket,
-}
-
-impl BorrowedSocket<'_> {
-    /// Returns a `BorrowedSocket` holding the given raw socket.
-    ///
-    /// # Safety
-    ///
-    /// The resource pointed to by `raw` must remain open for the duration of
-    /// the returned `BorrowedSocket`, and it must not have the value
-    /// `INVALID_SOCKET`.
-    #[inline]
-    #[cfg_attr(
-        staged_api,
-        rustc_const_stable(feature = "io_safety", since = "1.63.0")
-    )]
-    #[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-    pub const unsafe fn borrow_raw(socket: RawSocket) -> Self {
-        assert!(socket != c::INVALID_SOCKET as RawSocket);
-        Self {
-            socket,
-            _phantom: PhantomData,
-        }
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl AsRawSocket for BorrowedSocket<'_> {
-    #[inline]
-    fn as_raw_socket(&self) -> RawSocket {
-        self.socket
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl AsRawSocket for OwnedSocket {
-    #[inline]
-    fn as_raw_socket(&self) -> RawSocket {
-        self.socket
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl IntoRawSocket for OwnedSocket {
-    #[inline]
-    fn into_raw_socket(self) -> RawSocket {
-        let socket = self.socket;
-        forget(self);
-        socket
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl FromRawSocket for OwnedSocket {
-    #[inline]
-    unsafe fn from_raw_socket(socket: RawSocket) -> Self {
-        debug_assert_ne!(socket, c::INVALID_SOCKET as RawSocket);
-        Self { socket }
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl Drop for OwnedSocket {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            let _ = c::closesocket(self.socket as c::SOCKET);
-        }
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl fmt::Debug for BorrowedSocket<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("BorrowedSocket")
-            .field("socket", &self.socket)
-            .finish()
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl fmt::Debug for OwnedSocket {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnedSocket")
-            .field("socket", &self.socket)
-            .finish()
-    }
-}
-
-/// A trait to borrow the socket from an underlying object.
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-pub trait AsSocket {
-    /// Borrows the socket.
-    #[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-    fn as_socket(&self) -> BorrowedSocket<'_>;
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl<T: AsSocket> AsSocket for &T {
-    #[inline]
-    fn as_socket(&self) -> BorrowedSocket<'_> {
-        T::as_socket(self)
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl<T: AsSocket> AsSocket for &mut T {
-    #[inline]
-    fn as_socket(&self) -> BorrowedSocket<'_> {
-        T::as_socket(self)
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl AsSocket for BorrowedSocket<'_> {
-    #[inline]
-    fn as_socket(&self) -> BorrowedSocket<'_> {
-        *self
-    }
-}
-
-#[cfg_attr(staged_api, stable(feature = "io_safety", since = "1.63.0"))]
-impl AsSocket for OwnedSocket {
-    #[inline]
-    fn as_socket(&self) -> BorrowedSocket<'_> {
-        // Safety: `OwnedSocket` and `BorrowedSocket` have the same validity
-        // invariants, and the `BorrowdSocket` is bounded by the lifetime
-        // of `&self`.
-        unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
-    }
-}
diff --git a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/mod.rs b/vendor/rustix/src/maybe_polyfill/no_std/os/windows/mod.rs
deleted file mode 100644
index 02f38949..00000000
--- a/vendor/rustix/src/maybe_polyfill/no_std/os/windows/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! The following is derived from Rust's
-//! library/std/src/os/windows/raw.rs,
-//! library/std/src/os/windows/io/raw.rs and
-//! library/std/src/os/windows/io/socket.rs
-//! at revision
-//! 4f9b394c8a24803e57ba892fa00e539742ebafc0.
-//!
-//! All code in this file is licensed MIT or Apache 2.0 at your option.
-
-mod raw {
-    #[cfg(target_pointer_width = "32")]
-    #[cfg_attr(staged_api, stable(feature = "raw_ext", since = "1.1.0"))]
-    pub type SOCKET = u32;
-    #[cfg(target_pointer_width = "64")]
-    #[cfg_attr(staged_api, stable(feature = "raw_ext", since = "1.1.0"))]
-    pub type SOCKET = u64;
-}
-
-pub mod io;
diff --git a/vendor/rustix/src/maybe_polyfill/std/mod.rs b/vendor/rustix/src/maybe_polyfill/std/mod.rs
deleted file mode 100644
index 17b28095..00000000
--- a/vendor/rustix/src/maybe_polyfill/std/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//! Imports from `std` that would be polyfilled for `no_std` builds (see
-//! `src/polyfill/no_std`).
-//!
-//! This implementation is used when `std` is available and just imports the
-//! necessary items from `std`. For `no_std` builds, the file
-//! `src/polyfill/no_std` is used instead, which doesn't depend on the standard
-//! library.
-
-#[cfg(not(windows))]
-pub mod io {
-    pub use std::io::{IoSlice, IoSliceMut};
-}
-
-#[cfg(not(target_os = "wasi"))]
-#[cfg(feature = "net")]
-pub mod net {
-    pub use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
-}
-
-pub mod os {
-    pub mod fd {
-        // Change to use `std::os::fd` when MSRV becomes Rust 1.66 or higher.
-
-        #[cfg(target_os = "wasi")]
-        pub use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
-        #[cfg(unix)]
-        pub use std::os::unix::io::{
-            AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd,
-        };
-    }
-
-    #[cfg(windows)]
-    pub mod windows {
-        pub mod io {
-            pub use std::os::windows::io::{
-                AsRawSocket, AsSocket, BorrowedSocket, FromRawSocket, IntoRawSocket, OwnedSocket,
-                RawSocket,
-            };
-        }
-    }
-}