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

diff --git a/vendor/writeable/src/ops.rs b/vendor/writeable/src/ops.rs
deleted file mode 100644
index a4c1ffd7..00000000
--- a/vendor/writeable/src/ops.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-// This file is part of ICU4X. For terms of use, please see the file
-// called LICENSE at the top level of the ICU4X source tree
-// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
-
-use crate::LengthHint;
-
-impl core::ops::Add<LengthHint> for LengthHint {
-    type Output = Self;
-
-    fn add(self, other: LengthHint) -> Self {
-        LengthHint(
-            self.0.saturating_add(other.0),
-            match (self.1, other.1) {
-                (Some(c), Some(d)) => c.checked_add(d),
-                _ => None,
-            },
-        )
-    }
-}
-
-impl core::ops::AddAssign<LengthHint> for LengthHint {
-    fn add_assign(&mut self, other: Self) {
-        *self = *self + other;
-    }
-}
-
-impl core::iter::Sum<LengthHint> for LengthHint {
-    fn sum<I>(iter: I) -> Self
-    where
-        I: Iterator<Item = LengthHint>,
-    {
-        iter.fold(LengthHint::exact(0), core::ops::Add::add)
-    }
-}
-
-impl core::ops::Add<usize> for LengthHint {
-    type Output = Self;
-
-    fn add(self, other: usize) -> Self {
-        Self(
-            self.0.saturating_add(other),
-            self.1.and_then(|upper| upper.checked_add(other)),
-        )
-    }
-}
-
-impl core::ops::AddAssign<usize> for LengthHint {
-    fn add_assign(&mut self, other: usize) {
-        *self = *self + other;
-    }
-}
-
-impl core::ops::Mul<usize> for LengthHint {
-    type Output = Self;
-
-    fn mul(self, other: usize) -> Self {
-        Self(
-            self.0.saturating_mul(other),
-            self.1.and_then(|upper| upper.checked_mul(other)),
-        )
-    }
-}
-
-impl core::ops::MulAssign<usize> for LengthHint {
-    fn mul_assign(&mut self, other: usize) {
-        *self = *self * other;
-    }
-}
-
-impl core::ops::BitOr<LengthHint> for LengthHint {
-    type Output = Self;
-
-    /// Returns a new hint that is correct wherever `self` is correct, and wherever
-    /// `other` is correct.
-    ///
-    /// Example:
-    /// ```
-    /// # use writeable::{LengthHint, Writeable};
-    /// # use core::fmt;
-    /// # fn coin_flip() -> bool { true }
-    ///
-    /// struct NonDeterministicWriteable(String, String);
-    ///
-    /// impl Writeable for NonDeterministicWriteable {
-    ///     fn write_to<W: fmt::Write + ?Sized>(
-    ///         &self,
-    ///         sink: &mut W,
-    ///     ) -> fmt::Result {
-    ///         sink.write_str(if coin_flip() { &self.0 } else { &self.1 })
-    ///     }
-    ///
-    ///     fn writeable_length_hint(&self) -> LengthHint {
-    ///         LengthHint::exact(self.0.len()) | LengthHint::exact(self.1.len())
-    ///     }
-    /// }
-    ///
-    /// writeable::impl_display_with_writeable!(NonDeterministicWriteable);
-    /// ```
-    fn bitor(self, other: LengthHint) -> Self {
-        LengthHint(
-            Ord::min(self.0, other.0),
-            match (self.1, other.1) {
-                (Some(c), Some(d)) => Some(Ord::max(c, d)),
-                _ => None,
-            },
-        )
-    }
-}
-
-impl core::ops::BitOrAssign<LengthHint> for LengthHint {
-    fn bitor_assign(&mut self, other: Self) {
-        *self = *self | other;
-    }
-}
-
-impl core::iter::Sum<usize> for LengthHint {
-    fn sum<I>(iter: I) -> Self
-    where
-        I: Iterator<Item = usize>,
-    {
-        LengthHint::exact(iter.sum::<usize>())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_add() {
-        assert_eq!(LengthHint::exact(3) + 2, LengthHint::exact(5));
-        assert_eq!(
-            LengthHint::exact(3) + LengthHint::exact(2),
-            LengthHint::exact(5)
-        );
-        assert_eq!(
-            LengthHint::exact(3) + LengthHint::undefined(),
-            LengthHint::at_least(3)
-        );
-
-        assert_eq!(LengthHint::undefined() + 2, LengthHint::at_least(2));
-        assert_eq!(
-            LengthHint::undefined() + LengthHint::exact(2),
-            LengthHint::at_least(2)
-        );
-        assert_eq!(
-            LengthHint::undefined() + LengthHint::undefined(),
-            LengthHint::undefined()
-        );
-
-        assert_eq!(
-            LengthHint::at_least(15) + LengthHint::exact(3),
-            LengthHint::at_least(18)
-        );
-
-        assert_eq!(
-            LengthHint::at_least(15) + LengthHint::at_most(3),
-            LengthHint::at_least(15)
-        );
-
-        assert_eq!(LengthHint::between(48, 92) + 5, LengthHint::between(53, 97));
-
-        let mut len = LengthHint::exact(5);
-        len += LengthHint::exact(3);
-        assert_eq!(len, LengthHint::exact(8));
-        len += 2;
-        assert_eq!(len, LengthHint::exact(10));
-        len += LengthHint::undefined();
-        assert_eq!(len, LengthHint::at_least(10));
-
-        len += LengthHint::exact(3);
-        assert_eq!(len, LengthHint::at_least(13));
-        len += 2;
-        assert_eq!(len, LengthHint::at_least(15));
-        len += LengthHint::undefined();
-        assert_eq!(len, LengthHint::at_least(15));
-
-        assert_eq!(
-            LengthHint::between(usize::MAX - 10, usize::MAX - 5) + LengthHint::exact(20),
-            LengthHint::at_least(usize::MAX)
-        );
-    }
-
-    #[test]
-    fn test_sum() {
-        let lens = [
-            LengthHint::exact(4),
-            LengthHint::exact(1),
-            LengthHint::exact(1),
-        ];
-        assert_eq!(
-            lens.iter().copied().sum::<LengthHint>(),
-            LengthHint::exact(6)
-        );
-
-        let lens = [
-            LengthHint::exact(4),
-            LengthHint::undefined(),
-            LengthHint::at_least(1),
-        ];
-        assert_eq!(
-            lens.iter().copied().sum::<LengthHint>(),
-            LengthHint::at_least(5)
-        );
-
-        let lens = [
-            LengthHint::exact(4),
-            LengthHint::undefined(),
-            LengthHint::at_most(1),
-        ];
-        assert_eq!(
-            lens.iter().copied().sum::<LengthHint>(),
-            LengthHint::at_least(4)
-        );
-
-        let lens = [4, 1, 1];
-        assert_eq!(
-            lens.iter().copied().sum::<LengthHint>(),
-            LengthHint::exact(6)
-        );
-    }
-
-    #[test]
-    fn test_mul() {
-        assert_eq!(LengthHint::exact(3) * 2, LengthHint::exact(6));
-
-        assert_eq!(LengthHint::undefined() * 2, LengthHint::undefined());
-
-        assert_eq!(
-            LengthHint::between(48, 92) * 2,
-            LengthHint::between(96, 184)
-        );
-
-        let mut len = LengthHint::exact(5);
-        len *= 2;
-        assert_eq!(len, LengthHint::exact(10));
-
-        assert_eq!(
-            LengthHint::between(usize::MAX - 10, usize::MAX - 5) * 2,
-            LengthHint::at_least(usize::MAX)
-        );
-    }
-
-    #[test]
-    fn test_bitor() {
-        assert_eq!(
-            LengthHint::exact(3) | LengthHint::exact(2),
-            LengthHint::between(2, 3)
-        );
-        assert_eq!(
-            LengthHint::exact(3) | LengthHint::undefined(),
-            LengthHint::undefined()
-        );
-
-        assert_eq!(
-            LengthHint::undefined() | LengthHint::undefined(),
-            LengthHint::undefined()
-        );
-
-        assert_eq!(
-            LengthHint::exact(10) | LengthHint::exact(10),
-            LengthHint::exact(10)
-        );
-
-        assert_eq!(
-            LengthHint::at_least(15) | LengthHint::exact(3),
-            LengthHint::at_least(3)
-        );
-
-        assert_eq!(
-            LengthHint::at_least(15) | LengthHint::at_most(18),
-            LengthHint::undefined()
-        );
-
-        assert_eq!(
-            LengthHint::at_least(15) | LengthHint::at_least(18),
-            LengthHint::at_least(15)
-        );
-
-        assert_eq!(
-            LengthHint::at_most(15) | LengthHint::at_most(18),
-            LengthHint::at_most(18)
-        );
-
-        assert_eq!(
-            LengthHint::between(5, 10) | LengthHint::at_most(3),
-            LengthHint::at_most(10)
-        );
-
-        let mut len = LengthHint::exact(5);
-        len |= LengthHint::exact(3);
-        assert_eq!(len, LengthHint::between(5, 3));
-    }
-}