complete the FEC and "linear algebra" tests

• komodo::linalg::Matrix::random is tested
• komodo::linalg::Matrix::inverse is tested on more matrix sizes, from 1 to 20 random matrices
• komodo::field tests have been double-checked
• pure "recoding" tests from komodo::fec have been double-checked
• end_to_end and end_to_end_with_recoding now runs for k \in [3, 5] and \rho \in [\frac{1}{2}, \frac{1}{3}] with n = \lfloor \frac{k}{\rho} \rfloor
• all "k among n + t" combinations are tested with try_all_decoding_combinations, possibly with some removals in case recoding is involved with is_inside

Important
on my machine, make test goes from less than 8sec on latest main to around 40sec with this MR

src/fec.rs

@@ -217,24 +217,28 @@ mod tests {
         F::from_le_bytes_mod_order(&n.to_le_bytes())
     }
 
-    fn is_inside(set: &[Vec<usize>], x: &[usize]) -> bool {
+    /// `contains_one_of(x, set)` is true iif `x` fully contains one of the lists from `set`
+    ///
+    /// > **Note**  
+    /// > see [`containment`] for some example
+    fn contains_one_of(x: &[usize], set: &[Vec<usize>]) -> bool {
         set.iter().any(|y| y.iter().all(|z| x.contains(z)))
     }
 
     #[test]
-    fn exclusion() {
-        assert!(is_inside(&[vec![1, 2, 3]], &[1, 2, 3]));
-        assert!(is_inside(
+    fn containment() {
+        assert!(contains_one_of(&[1, 2, 3], &[vec![1, 2, 3]]));
+        assert!(contains_one_of(
+            &[3, 6, 8],
             &[vec![2, 4, 6], vec![1, 3, 7], vec![6, 7, 8], vec![3, 6, 8]],
-            &[3, 6, 8]
         ));
-        assert!(!is_inside(
+        assert!(!contains_one_of(
+            &[1, 6, 8],
             &[vec![2, 4, 6], vec![1, 3, 7], vec![6, 7, 8], vec![3, 6, 8]],
-            &[1, 6, 8]
         ));
-        assert!(is_inside(
+        assert!(contains_one_of(
+            &[3, 6, 8, 9, 10],
             &[vec![2, 4, 6], vec![1, 3, 7], vec![6, 7, 8], vec![3, 6, 8]],
-            &[3, 6, 8, 9, 10]
         ));
     }
 
@@ -244,7 +248,7 @@ mod tests {
         k: usize,
         test_case: &str,
         limit: Option<usize>,
-        exclude: Vec<Vec<usize>>,
+        should_not_be_decodable: Vec<Vec<usize>>,
     ) {
         for c in shards
             .iter()
@@ -258,7 +262,7 @@ mod tests {
 
             let actual = decode::<F>(s);
 
-            if is_inside(&exclude, &is) {
+            if contains_one_of(&is, &should_not_be_decodable) {
                 assert!(
                     actual.is_err(),
                     "should not decode with {:?} {test_case}",