feat: vendor midstream and sublinear-time-solver libraries (#109)

Add ruvnet/midstream (AIMDS real-time inference) and
ruvnet/sublinear-time-solver (sublinear optimization algorithms)
as vendored dependencies under vendor/.

vendor/sublinear-time-solver/src/sublinear/dimension_reduction.rs

@@ -0,0 +1,103 @@
+//! Dimension reduction techniques for sublinear algorithms
+
+use crate::types::Precision;
+use crate::error::{SolverError, Result};
+use crate::sublinear::johnson_lindenstrauss::JLEmbedding;
+use alloc::{vec::Vec, string::String};
+
+/// Dimension reduction method
+#[derive(Debug, Clone, PartialEq)]
+pub enum ReductionMethod {
+    /// Johnson-Lindenstrauss embedding
+    JohnsonLindenstrauss,
+    /// Random projection
+    RandomProjection,
+    /// Principal Component Analysis (simplified)
+    PCA,
+    /// Sparse random projection
+    SparseRandomProjection,
+}
+
+/// Dimension reduction engine
+#[derive(Debug)]
+pub struct DimensionReducer {
+    method: ReductionMethod,
+    original_dim: usize,
+    target_dim: usize,
+    jl_embedding: Option<JLEmbedding>,
+}
+
+impl DimensionReducer {
+    /// Create new dimension reducer
+    pub fn new(
+        method: ReductionMethod,
+        original_dim: usize,
+        target_dim: usize,
+        distortion: Option<Precision>,
+        seed: Option<u64>,
+    ) -> Result<Self> {
+        if target_dim > original_dim {
+            return Err(SolverError::InvalidInput {
+                message: "Target dimension must be <= original dimension".to_string(),
+                parameter: Some("target_dim".to_string()),
+            });
+        }
+
+        let jl_embedding = if method == ReductionMethod::JohnsonLindenstrauss {
+            Some(JLEmbedding::new(original_dim, distortion.unwrap_or(0.1), seed)?)
+        } else {
+            None
+        };
+
+        Ok(Self {
+            method,
+            original_dim,
+            target_dim,
+            jl_embedding,
+        })
+    }
+
+    /// Reduce dimension of vector
+    pub fn reduce_vector(&self, vector: &[Precision]) -> Result<Vec<Precision>> {
+        match self.method {
+            ReductionMethod::JohnsonLindenstrauss => {
+                if let Some(ref jl) = self.jl_embedding {
+                    jl.project_vector(vector)
+                } else {
+                    Err(SolverError::AlgorithmError {
+                        algorithm: "dimension_reduction".to_string(),
+                        message: "JL embedding not initialized".to_string(),
+                        context: vec![],
+                    })
+                }
+            }
+            _ => {
+                // Simple truncation for other methods
+                Ok(vector[..self.target_dim.min(vector.len())].to_vec())
+            }
+        }
+    }
+
+    /// Reconstruct vector in original space
+    pub fn reconstruct_vector(&self, reduced: &[Precision]) -> Result<Vec<Precision>> {
+        match self.method {
+            ReductionMethod::JohnsonLindenstrauss => {
+                if let Some(ref jl) = self.jl_embedding {
+                    jl.reconstruct_vector(reduced)
+                } else {
+                    Err(SolverError::AlgorithmError {
+                        algorithm: "dimension_reduction".to_string(),
+                        message: "JL embedding not initialized".to_string(),
+                        context: vec![],
+                    })
+                }
+            }
+            _ => {
+                // Simple padding for other methods
+                let mut reconstructed = reduced.to_vec();
+                reconstructed.resize(self.original_dim, 0.0);
+                Ok(reconstructed)
+            }
+        }
+    }
+}