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

diff --git a/vendor/itertools/src/lazy_buffer.rs b/vendor/itertools/src/lazy_buffer.rs
deleted file mode 100644
index fafa5f72..00000000
--- a/vendor/itertools/src/lazy_buffer.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use alloc::vec::Vec;
-use std::iter::Fuse;
-use std::ops::Index;
-
-use crate::size_hint::{self, SizeHint};
-
-#[derive(Debug, Clone)]
-pub struct LazyBuffer<I: Iterator> {
-    it: Fuse<I>,
-    buffer: Vec<I::Item>,
-}
-
-impl<I> LazyBuffer<I>
-where
-    I: Iterator,
-{
-    pub fn new(it: I) -> Self {
-        Self {
-            it: it.fuse(),
-            buffer: Vec::new(),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.buffer.len()
-    }
-
-    pub fn size_hint(&self) -> SizeHint {
-        size_hint::add_scalar(self.it.size_hint(), self.len())
-    }
-
-    pub fn count(self) -> usize {
-        self.len() + self.it.count()
-    }
-
-    pub fn get_next(&mut self) -> bool {
-        if let Some(x) = self.it.next() {
-            self.buffer.push(x);
-            true
-        } else {
-            false
-        }
-    }
-
-    pub fn prefill(&mut self, len: usize) {
-        let buffer_len = self.buffer.len();
-        if len > buffer_len {
-            let delta = len - buffer_len;
-            self.buffer.extend(self.it.by_ref().take(delta));
-        }
-    }
-}
-
-impl<I> LazyBuffer<I>
-where
-    I: Iterator,
-    I::Item: Clone,
-{
-    pub fn get_at(&self, indices: &[usize]) -> Vec<I::Item> {
-        indices.iter().map(|i| self.buffer[*i].clone()).collect()
-    }
-
-    pub fn get_array<const K: usize>(&self, indices: [usize; K]) -> [I::Item; K] {
-        indices.map(|i| self.buffer[i].clone())
-    }
-}
-
-impl<I, J> Index<J> for LazyBuffer<I>
-where
-    I: Iterator,
-    I::Item: Sized,
-    Vec<I::Item>: Index<J>,
-{
-    type Output = <Vec<I::Item> as Index<J>>::Output;
-
-    fn index(&self, index: J) -> &Self::Output {
-        self.buffer.index(index)
-    }
-}