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.

1 files changed, 0 insertions, 211 deletions

diff --git a/vendor/http/src/uri/builder.rs b/vendor/http/src/uri/builder.rs
deleted file mode 100644
index d5f7f49b..00000000
--- a/vendor/http/src/uri/builder.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-use std::convert::TryInto;
-
-use super::{Authority, Parts, PathAndQuery, Scheme};
-use crate::Uri;
-
-/// A builder for `Uri`s.
-///
-/// This type can be used to construct an instance of `Uri`
-/// through a builder pattern.
-#[derive(Debug)]
-pub struct Builder {
-    parts: Result<Parts, crate::Error>,
-}
-
-impl Builder {
-    /// Creates a new default instance of `Builder` to construct a `Uri`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use http::*;
-    ///
-    /// let uri = uri::Builder::new()
-    ///     .scheme("https")
-    ///     .authority("hyper.rs")
-    ///     .path_and_query("/")
-    ///     .build()
-    ///     .unwrap();
-    /// ```
-    #[inline]
-    pub fn new() -> Builder {
-        Builder::default()
-    }
-
-    /// Set the `Scheme` for this URI.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use http::*;
-    ///
-    /// let mut builder = uri::Builder::new();
-    /// builder.scheme("https");
-    /// ```
-    pub fn scheme<T>(self, scheme: T) -> Self
-    where
-        T: TryInto<Scheme>,
-        <T as TryInto<Scheme>>::Error: Into<crate::Error>,
-    {
-        self.map(move |mut parts| {
-            let scheme = scheme.try_into().map_err(Into::into)?;
-            parts.scheme = Some(scheme);
-            Ok(parts)
-        })
-    }
-
-    /// Set the `Authority` for this URI.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use http::*;
-    ///
-    /// let uri = uri::Builder::new()
-    ///     .authority("tokio.rs")
-    ///     .build()
-    ///     .unwrap();
-    /// ```
-    pub fn authority<T>(self, auth: T) -> Self
-    where
-        T: TryInto<Authority>,
-        <T as TryInto<Authority>>::Error: Into<crate::Error>,
-    {
-        self.map(move |mut parts| {
-            let auth = auth.try_into().map_err(Into::into)?;
-            parts.authority = Some(auth);
-            Ok(parts)
-        })
-    }
-
-    /// Set the `PathAndQuery` for this URI.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use http::*;
-    ///
-    /// let uri = uri::Builder::new()
-    ///     .path_and_query("/hello?foo=bar")
-    ///     .build()
-    ///     .unwrap();
-    /// ```
-    pub fn path_and_query<T>(self, p_and_q: T) -> Self
-    where
-        T: TryInto<PathAndQuery>,
-        <T as TryInto<PathAndQuery>>::Error: Into<crate::Error>,
-    {
-        self.map(move |mut parts| {
-            let p_and_q = p_and_q.try_into().map_err(Into::into)?;
-            parts.path_and_query = Some(p_and_q);
-            Ok(parts)
-        })
-    }
-
-    /// Consumes this builder, and tries to construct a valid `Uri` from
-    /// the configured pieces.
-    ///
-    /// # Errors
-    ///
-    /// This function may return an error if any previously configured argument
-    /// failed to parse or get converted to the internal representation. For
-    /// example if an invalid `scheme` was specified via `scheme("!@#%/^")`
-    /// the error will be returned when this function is called rather than
-    /// when `scheme` was called.
-    ///
-    /// Additionally, the various forms of URI require certain combinations of
-    /// parts to be set to be valid. If the parts don't fit into any of the
-    /// valid forms of URI, a new error is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use http::*;
-    ///
-    /// let uri = Uri::builder()
-    ///     .build()
-    ///     .unwrap();
-    /// ```
-    pub fn build(self) -> Result<Uri, crate::Error> {
-        let parts = self.parts?;
-        Uri::from_parts(parts).map_err(Into::into)
-    }
-
-    // private
-
-    fn map<F>(self, func: F) -> Self
-    where
-        F: FnOnce(Parts) -> Result<Parts, crate::Error>,
-    {
-        Builder {
-            parts: self.parts.and_then(func),
-        }
-    }
-}
-
-impl Default for Builder {
-    #[inline]
-    fn default() -> Builder {
-        Builder {
-            parts: Ok(Parts::default()),
-        }
-    }
-}
-
-impl From<Uri> for Builder {
-    fn from(uri: Uri) -> Self {
-        Self {
-            parts: Ok(uri.into_parts()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn build_from_str() {
-        let uri = Builder::new()
-            .scheme(Scheme::HTTP)
-            .authority("hyper.rs")
-            .path_and_query("/foo?a=1")
-            .build()
-            .unwrap();
-        assert_eq!(uri.scheme_str(), Some("http"));
-        assert_eq!(uri.authority().unwrap().host(), "hyper.rs");
-        assert_eq!(uri.path(), "/foo");
-        assert_eq!(uri.query(), Some("a=1"));
-    }
-
-    #[test]
-    fn build_from_string() {
-        for i in 1..10 {
-            let uri = Builder::new()
-                .path_and_query(format!("/foo?a={}", i))
-                .build()
-                .unwrap();
-            let expected_query = format!("a={}", i);
-            assert_eq!(uri.path(), "/foo");
-            assert_eq!(uri.query(), Some(expected_query.as_str()));
-        }
-    }
-
-    #[test]
-    fn build_from_string_ref() {
-        for i in 1..10 {
-            let p_a_q = format!("/foo?a={}", i);
-            let uri = Builder::new().path_and_query(&p_a_q).build().unwrap();
-            let expected_query = format!("a={}", i);
-            assert_eq!(uri.path(), "/foo");
-            assert_eq!(uri.query(), Some(expected_query.as_str()));
-        }
-    }
-
-    #[test]
-    fn build_from_uri() {
-        let original_uri = Uri::default();
-        let uri = Builder::from(original_uri.clone()).build().unwrap();
-        assert_eq!(original_uri, uri);
-    }
-}