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, 127 deletions

diff --git a/vendor/bytes/src/buf/iter.rs b/vendor/bytes/src/buf/iter.rs
deleted file mode 100644
index 74f9b991..00000000
--- a/vendor/bytes/src/buf/iter.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use crate::Buf;
-
-/// Iterator over the bytes contained by the buffer.
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// use bytes::Bytes;
-///
-/// let buf = Bytes::from(&b"abc"[..]);
-/// let mut iter = buf.into_iter();
-///
-/// assert_eq!(iter.next(), Some(b'a'));
-/// assert_eq!(iter.next(), Some(b'b'));
-/// assert_eq!(iter.next(), Some(b'c'));
-/// assert_eq!(iter.next(), None);
-/// ```
-#[derive(Debug)]
-pub struct IntoIter<T> {
-    inner: T,
-}
-
-impl<T> IntoIter<T> {
-    /// Creates an iterator over the bytes contained by the buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let buf = Bytes::from_static(b"abc");
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    /// assert_eq!(iter.next(), Some(b'b'));
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    pub fn new(inner: T) -> IntoIter<T> {
-        IntoIter { inner }
-    }
-
-    /// Consumes this `IntoIter`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// let buf = iter.into_inner();
-    /// assert_eq!(2, buf.remaining());
-    /// ```
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// assert_eq!(2, iter.get_ref().remaining());
-    /// ```
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BytesMut};
-    ///
-    /// let buf = BytesMut::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// iter.get_mut().advance(1);
-    ///
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-}
-
-impl<T: Buf> Iterator for IntoIter<T> {
-    type Item = u8;
-
-    fn next(&mut self) -> Option<u8> {
-        if !self.inner.has_remaining() {
-            return None;
-        }
-
-        let b = self.inner.chunk()[0];
-        self.inner.advance(1);
-
-        Some(b)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let rem = self.inner.remaining();
-        (rem, Some(rem))
-    }
-}
-
-impl<T: Buf> ExactSizeIterator for IntoIter<T> {}