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

diff --git a/vendor/itertools/src/free.rs b/vendor/itertools/src/free.rs
deleted file mode 100644
index 4c682054..00000000
--- a/vendor/itertools/src/free.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-//! Free functions that create iterator adaptors or call iterator methods.
-//!
-//! The benefit of free functions is that they accept any [`IntoIterator`] as
-//! argument, so the resulting code may be easier to read.
-
-#[cfg(feature = "use_alloc")]
-use std::fmt::Display;
-use std::iter::{self, Zip};
-#[cfg(feature = "use_alloc")]
-type VecIntoIter<T> = alloc::vec::IntoIter<T>;
-
-#[cfg(feature = "use_alloc")]
-use alloc::string::String;
-
-use crate::intersperse::{Intersperse, IntersperseWith};
-use crate::Itertools;
-
-pub use crate::adaptors::{interleave, put_back};
-#[cfg(feature = "use_alloc")]
-pub use crate::kmerge_impl::kmerge;
-pub use crate::merge_join::{merge, merge_join_by};
-#[cfg(feature = "use_alloc")]
-pub use crate::multipeek_impl::multipeek;
-#[cfg(feature = "use_alloc")]
-pub use crate::peek_nth::peek_nth;
-#[cfg(feature = "use_alloc")]
-pub use crate::put_back_n_impl::put_back_n;
-#[cfg(feature = "use_alloc")]
-pub use crate::rciter_impl::rciter;
-pub use crate::zip_eq_impl::zip_eq;
-
-/// Iterate `iterable` with a particular value inserted between each element.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::intersperse`].
-///
-/// ```
-/// use itertools::intersperse;
-///
-/// itertools::assert_equal(intersperse(0..3, 8), vec![0, 8, 1, 8, 2]);
-/// ```
-pub fn intersperse<I>(iterable: I, element: I::Item) -> Intersperse<I::IntoIter>
-where
-    I: IntoIterator,
-    <I as IntoIterator>::Item: Clone,
-{
-    Itertools::intersperse(iterable.into_iter(), element)
-}
-
-/// Iterate `iterable` with a particular value created by a function inserted
-/// between each element.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::intersperse_with`].
-///
-/// ```
-/// use itertools::intersperse_with;
-///
-/// let mut i = 10;
-/// itertools::assert_equal(intersperse_with(0..3, || { i -= 1; i }), vec![0, 9, 1, 8, 2]);
-/// assert_eq!(i, 8);
-/// ```
-pub fn intersperse_with<I, F>(iterable: I, element: F) -> IntersperseWith<I::IntoIter, F>
-where
-    I: IntoIterator,
-    F: FnMut() -> I::Item,
-{
-    Itertools::intersperse_with(iterable.into_iter(), element)
-}
-
-/// Iterate `iterable` with a running index.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::enumerate`].
-///
-/// ```
-/// use itertools::enumerate;
-///
-/// for (i, elt) in enumerate(&[1, 2, 3]) {
-///     /* loop body */
-///     # let _ = (i, elt);
-/// }
-/// ```
-pub fn enumerate<I>(iterable: I) -> iter::Enumerate<I::IntoIter>
-where
-    I: IntoIterator,
-{
-    iterable.into_iter().enumerate()
-}
-
-/// Iterate `iterable` in reverse.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::rev`].
-///
-/// ```
-/// use itertools::rev;
-///
-/// for elt in rev(&[1, 2, 3]) {
-///     /* loop body */
-///     # let _ = elt;
-/// }
-/// ```
-pub fn rev<I>(iterable: I) -> iter::Rev<I::IntoIter>
-where
-    I: IntoIterator,
-    I::IntoIter: DoubleEndedIterator,
-{
-    iterable.into_iter().rev()
-}
-
-/// Converts the arguments to iterators and zips them.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::zip`].
-///
-/// ## Example
-///
-/// ```
-/// use itertools::zip;
-///
-/// let mut result: Vec<(i32, char)> = Vec::new();
-///
-/// for (a, b) in zip(&[1, 2, 3, 4, 5], &['a', 'b', 'c']) {
-///     result.push((*a, *b));
-/// }
-/// assert_eq!(result, vec![(1, 'a'),(2, 'b'),(3, 'c')]);
-/// ```
-#[deprecated(
-    note = "Use [std::iter::zip](https://doc.rust-lang.org/std/iter/fn.zip.html) instead",
-    since = "0.10.4"
-)]
-pub fn zip<I, J>(i: I, j: J) -> Zip<I::IntoIter, J::IntoIter>
-where
-    I: IntoIterator,
-    J: IntoIterator,
-{
-    i.into_iter().zip(j)
-}
-
-/// Takes two iterables and creates a new iterator over both in sequence.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::chain`].
-///
-/// ## Example
-/// ```
-/// use itertools::chain;
-///
-/// let mut result:Vec<i32> = Vec::new();
-///
-/// for element in chain(&[1, 2, 3], &[4]) {
-///     result.push(*element);
-/// }
-/// assert_eq!(result, vec![1, 2, 3, 4]);
-/// ```
-pub fn chain<I, J>(
-    i: I,
-    j: J,
-) -> iter::Chain<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>
-where
-    I: IntoIterator,
-    J: IntoIterator<Item = I::Item>,
-{
-    i.into_iter().chain(j)
-}
-
-/// Create an iterator that clones each element from `&T` to `T`.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::cloned`].
-///
-/// ```
-/// use itertools::cloned;
-///
-/// assert_eq!(cloned(b"abc").next(), Some(b'a'));
-/// ```
-pub fn cloned<'a, I, T>(iterable: I) -> iter::Cloned<I::IntoIter>
-where
-    I: IntoIterator<Item = &'a T>,
-    T: Clone + 'a,
-{
-    iterable.into_iter().cloned()
-}
-
-/// Perform a fold operation over the iterable.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::fold`].
-///
-/// ```
-/// use itertools::fold;
-///
-/// assert_eq!(fold(&[1., 2., 3.], 0., |a, &b| f32::max(a, b)), 3.);
-/// ```
-pub fn fold<I, B, F>(iterable: I, init: B, f: F) -> B
-where
-    I: IntoIterator,
-    F: FnMut(B, I::Item) -> B,
-{
-    iterable.into_iter().fold(init, f)
-}
-
-/// Test whether the predicate holds for all elements in the iterable.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::all`].
-///
-/// ```
-/// use itertools::all;
-///
-/// assert!(all(&[1, 2, 3], |elt| *elt > 0));
-/// ```
-pub fn all<I, F>(iterable: I, f: F) -> bool
-where
-    I: IntoIterator,
-    F: FnMut(I::Item) -> bool,
-{
-    iterable.into_iter().all(f)
-}
-
-/// Test whether the predicate holds for any elements in the iterable.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::any`].
-///
-/// ```
-/// use itertools::any;
-///
-/// assert!(any(&[0, -1, 2], |elt| *elt > 0));
-/// ```
-pub fn any<I, F>(iterable: I, f: F) -> bool
-where
-    I: IntoIterator,
-    F: FnMut(I::Item) -> bool,
-{
-    iterable.into_iter().any(f)
-}
-
-/// Return the maximum value of the iterable.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::max`].
-///
-/// ```
-/// use itertools::max;
-///
-/// assert_eq!(max(0..10), Some(9));
-/// ```
-pub fn max<I>(iterable: I) -> Option<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Ord,
-{
-    iterable.into_iter().max()
-}
-
-/// Return the minimum value of the iterable.
-///
-/// [`IntoIterator`] enabled version of [`Iterator::min`].
-///
-/// ```
-/// use itertools::min;
-///
-/// assert_eq!(min(0..10), Some(0));
-/// ```
-pub fn min<I>(iterable: I) -> Option<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Ord,
-{
-    iterable.into_iter().min()
-}
-
-/// Combine all iterator elements into one `String`, separated by `sep`.
-///
-/// [`IntoIterator`] enabled version of [`Itertools::join`].
-///
-/// ```
-/// use itertools::join;
-///
-/// assert_eq!(join(&[1, 2, 3], ", "), "1, 2, 3");
-/// ```
-#[cfg(feature = "use_alloc")]
-pub fn join<I>(iterable: I, sep: &str) -> String
-where
-    I: IntoIterator,
-    I::Item: Display,
-{
-    iterable.into_iter().join(sep)
-}
-
-/// Sort all iterator elements into a new iterator in ascending order.
-///
-/// [`IntoIterator`] enabled version of [`Itertools::sorted`].
-///
-/// ```
-/// use itertools::sorted;
-/// use itertools::assert_equal;
-///
-/// assert_equal(sorted("rust".chars()), "rstu".chars());
-/// ```
-#[cfg(feature = "use_alloc")]
-pub fn sorted<I>(iterable: I) -> VecIntoIter<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Ord,
-{
-    iterable.into_iter().sorted()
-}
-
-/// Sort all iterator elements into a new iterator in ascending order.
-/// This sort is unstable (i.e., may reorder equal elements).
-///
-/// [`IntoIterator`] enabled version of [`Itertools::sorted_unstable`].
-///
-/// ```
-/// use itertools::sorted_unstable;
-/// use itertools::assert_equal;
-///
-/// assert_equal(sorted_unstable("rust".chars()), "rstu".chars());
-/// ```
-#[cfg(feature = "use_alloc")]
-pub fn sorted_unstable<I>(iterable: I) -> VecIntoIter<I::Item>
-where
-    I: IntoIterator,
-    I::Item: Ord,
-{
-    iterable.into_iter().sorted_unstable()
-}