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

diff --git a/vendor/petgraph/src/macros.rs b/vendor/petgraph/src/macros.rs
deleted file mode 100644
index 9ecb9002..00000000
--- a/vendor/petgraph/src/macros.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-macro_rules! clone_fields {
-    ($name:ident, $($field:ident),+ $(,)*) => (
-        fn clone(&self) -> Self {
-            $name {
-                $(
-                    $field : self . $field .clone()
-                ),*
-            }
-        }
-    );
-}
-
-macro_rules! iterator_wrap {
-    (impl () for
-    struct $name: ident <$($typarm:tt),*> where { $($bounds: tt)* }
-     item: $item: ty,
-     iter: $iter: ty,
-     ) => ();
-    (
-    impl (Iterator $($rest:tt)*)  for
-    $(#[$derive:meta])*
-     struct $name: ident <$($typarm:tt),*> where { $($bounds: tt)* }
-     item: $item: ty,
-     iter: $iter: ty,
-     ) => (
-        // having complex iterator types is kind of the point of this macro
-        #[allow(clippy::type_complexity)]
-        $(#[$derive])*
-        pub struct $name <$($typarm),*> where $($bounds)* {
-            iter: $iter,
-        }
-        impl<$($typarm),*> Iterator for $name <$($typarm),*>
-            where $($bounds)*
-        {
-            type Item = $item;
-            #[inline]
-            fn next(&mut self) -> Option<Self::Item> {
-                self.iter.next()
-            }
-
-            #[inline]
-            fn size_hint(&self) -> (usize, Option<usize>) {
-                self.iter.size_hint()
-            }
-        }
-        iterator_wrap!(
-            impl ($($rest)*)  for
-            struct $name <$($typarm),*> where { $($bounds)* }
-            item: $item,
-            iter: $iter,
-            );
-        );
-
-    (
-impl (ExactSizeIterator $($rest:tt)*)  for
-    $(#[$derive:meta])*
-     struct $name: ident <$($typarm:tt),*> where { $($bounds: tt)* }
-     item: $item: ty,
-     iter: $iter: ty,
-     ) => (
-        impl<$($typarm),*> ExactSizeIterator for $name <$($typarm),*>
-            where $($bounds)*
-        {
-            #[inline]
-            fn len(&self) -> usize {
-                self.iter.len()
-            }
-        }
-        iterator_wrap!(
-            impl ($($rest)*)  for
-         $(#[$derive])*
-            struct $name <$($typarm),*> where { $($bounds)* }
-            item: $item,
-            iter: $iter,
-            );
-    );
-
-    (
-impl (DoubleEndedIterator $($rest:tt)*)  for
-    $(#[$derive:meta])*
-     struct $name: ident <$($typarm:tt),*> where { $($bounds: tt)* }
-     item: $item: ty,
-     iter: $iter: ty,
-     ) => (
-        impl<$($typarm),*> DoubleEndedIterator for $name <$($typarm),*>
-            where $($bounds)*
-        {
-            fn next_back(&mut self) -> Option<Self::Item> {
-                self.iter.next_back()
-            }
-            fn rfold<B, F>(self, accum: B, f: F) -> B
-                where
-                    F: FnMut(B, Self::Item) -> B,
-                { self.iter.rfold(accum, f) }
-            fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
-                where
-                    P: FnMut(&Self::Item) -> bool,
-                { self.iter.rfind(predicate) }
-        }
-        iterator_wrap!(
-            impl ($($rest)*)  for
-         $(#[$derive])*
-           struct $name <$($typarm),*> where { $($bounds)* }
-            item: $item,
-            iter: $iter,
-            );
-    );
-}