tests: Stop using inventory crate

I was reading this thread
https://internals.rust-lang.org/t/from-life-before-main-to-common-life-in-main/16006/30
and that reminded me about this code, which it turns out actually
doesn't compile with my default local cargo config:
```
$ cat ~/.cargo/config
[target.x86_64-unknown-linux-gnu]
rustflags = ["-Ctarget-cpu=native", "-C", "link-arg=-fuse-ld=lld"]

[profile.release]
incremental = true
$ cargo b
...
error: linking with `cc` failed: exit status: 1
  |
  = note: "cc" "-m64" "/var/srv/walters/src/github/ostreedev/ostree/target/debug/deps/ostree_test-4ca8e730f9dc6ffc.10325uqlhkyr5uol.rcgu.o" "/var/srv/walte"
  = note: ld.lld: error: undefined symbol: __start_linkme_NONDESTRUCTIVE_TESTS
          >>> referenced by 22nn09lfsklfqvyy
          >>>               /var/srv/walters/src/github/ostreedev/ostree/target/debug/deps/ostree_test-4ca8e730f9dc6ffc.22nn09lfsklfqvyy.rcgu.o:(ostree_tes)

```

For now let's just go back to having a static list of functions.
We don't have *too* many of those.

tests/inst/src/destructive.rs

@@ -537,8 +537,7 @@ fn impl_transaction_test<M: AsRef<str>>(
     }
 }
 
-#[itest(destructive = true)]
-fn transactionality() -> Result<()> {
+pub(crate) fn itest_transactionality() -> Result<()> {
     testinit()?;
     let mark = get_reboot_mark()?;
     let cancellable = Some(gio::Cancellable::new());

tests/inst/src/insttestmain.rs

@@ -10,6 +10,25 @@ mod treegen;
 // Written by Ignition
 const DESTRUCTIVE_TEST_STAMP: &str = "/etc/ostree-destructive-test-ok";
 
+macro_rules! test {
+    ($f: path) => {
+        (stringify!($f), $f)
+    };
+}
+
+type StaticTest = (&'static str, fn() -> Result<()>);
+
+const TESTS: &[StaticTest] = &[
+    test!(sysroot::itest_sysroot_ro),
+    test!(sysroot::itest_immutable_bit),
+    test!(sysroot::itest_tmpfiles),
+    test!(repobin::itest_basic),
+    test!(repobin::itest_nofifo),
+    test!(repobin::itest_extensions),
+    test!(repobin::itest_pull_basicauth),
+];
+const DESTRUCTIVE_TESTS: &[StaticTest] = &[test!(destructive::itest_transactionality)];
+
 #[derive(Debug, StructOpt)]
 #[structopt(rename_all = "kebab-case")]
 #[allow(clippy::enum_variant_names)]
@@ -30,18 +49,18 @@ enum NonDestructiveOpts {
     Args(Vec<String>),
 }
 
-fn libtest_from_test(t: &'static test::Test) -> test::TestImpl {
+fn libtest_from_test(t: &StaticTest) -> test::TestImpl {
     libtest_mimic::Test {
-        name: t.name.into(),
+        name: t.0.into(),
         kind: "".into(),
         is_ignored: false,
         is_bench: false,
-        data: t,
+        data: t.1,
     }
 }
 
 fn run_test(test: &test::TestImpl) -> libtest_mimic::Outcome {
-    if let Err(e) = (test.data.f)() {
+    if let Err(e) = (test.data)() {
         libtest_mimic::Outcome::Failed {
             msg: Some(e.to_string()),
         }
@@ -72,8 +91,8 @@ fn main() -> Result<()> {
 
     match opt {
         Opt::ListDestructive => {
-            for t in test::DESTRUCTIVE_TESTS.iter() {
-                println!("{}", t.name);
+            for t in DESTRUCTIVE_TESTS {
+                println!("{}", t.0);
             }
             Ok(())
         }
@@ -81,10 +100,7 @@ fn main() -> Result<()> {
             // FIXME add method to parse subargs
             let NonDestructiveOpts::Args(iter) = subopt;
             let libtestargs = libtest_mimic::Arguments::from_iter(iter);
-            let tests: Vec<_> = test::NONDESTRUCTIVE_TESTS
-                .iter()
-                .map(libtest_from_test)
-                .collect();
+            let tests: Vec<_> = TESTS.iter().map(libtest_from_test).collect();
             libtest_mimic::run_tests(&libtestargs, tests, run_test).exit();
         }
         Opt::RunDestructive { name } => {
@@ -98,10 +114,10 @@ fn main() -> Result<()> {
                 bail!("An ostree-based host is required")
             }
 
-            for t in test::DESTRUCTIVE_TESTS.iter() {
-                if t.name == name {
-                    (t.f)()?;
-                    println!("ok destructive test: {}", t.name);
+            for (tname, f) in DESTRUCTIVE_TESTS {
+                if *tname == name.as_str() {
+                    (f)()?;
+                    println!("ok destructive test: {}", tname);
                     return Ok(());
                 }
             }

tests/inst/src/repobin.rs

@@ -8,15 +8,13 @@ use anyhow::{Context, Result};
 use sh_inline::{bash, bash_command};
 use with_procspawn_tempdir::with_procspawn_tempdir;
 
-#[itest]
-fn test_basic() -> Result<()> {
+pub(crate) fn itest_basic() -> Result<()> {
     bash!(r"ostree --help >/dev/null")?;
     Ok(())
 }
 
-#[itest]
 #[with_procspawn_tempdir]
-fn test_nofifo() -> Result<()> {
+pub(crate) fn itest_nofifo() -> Result<()> {
     assert!(std::path::Path::new(".procspawn-tmpdir").exists());
     bash!(
         r"ostree --repo=repo init --mode=archive
@@ -34,9 +32,8 @@ fn test_nofifo() -> Result<()> {
     Ok(())
 }
 
-#[itest]
 #[with_procspawn_tempdir]
-fn test_mtime() -> Result<()> {
+pub(crate) fn itest_mtime() -> Result<()> {
     bash!(
         r"ostree --repo=repo init --mode=archive
     mkdir tmproot
@@ -50,17 +47,15 @@ fn test_mtime() -> Result<()> {
     Ok(())
 }
 
-#[itest]
 #[with_procspawn_tempdir]
-fn test_extensions() -> Result<()> {
+pub(crate) fn itest_extensions() -> Result<()> {
     bash!(r"ostree --repo=repo init --mode=bare")?;
     assert!(Path::new("repo/extensions").exists());
     Ok(())
 }
 
-#[itest]
 #[with_procspawn_tempdir]
-fn test_pull_basicauth() -> Result<()> {
+pub(crate) fn itest_pull_basicauth() -> Result<()> {
     let opts = TestHttpServerOpts {
         basicauth: true,
         ..Default::default()

tests/inst/src/sysroot.rs

@@ -13,8 +13,7 @@ fn skip_non_ostree_host() -> bool {
     !std::path::Path::new("/run/ostree-booted").exists()
 }
 
-#[itest]
-fn test_sysroot_ro() -> Result<()> {
+pub(crate) fn itest_sysroot_ro() -> Result<()> {
     // TODO add a skipped identifier
     if skip_non_ostree_host() {
         return Ok(());
@@ -39,8 +38,7 @@ fn test_sysroot_ro() -> Result<()> {
     Ok(())
 }
 
-#[itest]
-fn test_immutable_bit() -> Result<()> {
+pub(crate) fn itest_immutable_bit() -> Result<()> {
     if skip_non_ostree_host() {
         return Ok(());
     }
@@ -49,8 +47,7 @@ fn test_immutable_bit() -> Result<()> {
     Ok(())
 }
 
-#[itest]
-fn test_tmpfiles() -> Result<()> {
+pub(crate) fn itest_tmpfiles() -> Result<()> {
     if skip_non_ostree_host() {
         return Ok(());
     }

tests/inst/src/test.rs

@@ -6,10 +6,8 @@ use std::process::Command;
 use std::time;
 
 use anyhow::{bail, Context, Result};
-use linkme::distributed_slice;
 use rand::Rng;
 
-pub use itest_macro::itest;
 pub use with_procspawn_tempdir::with_procspawn_tempdir;
 
 // HTTP Server deps
@@ -20,19 +18,7 @@ use hyper_staticfile::Static;
 use tokio::runtime::Runtime;
 
 pub(crate) type TestFn = fn() -> Result<()>;
-
-#[derive(Debug)]
-pub(crate) struct Test {
-    pub(crate) name: &'static str,
-    pub(crate) f: TestFn,
-}
-
-pub(crate) type TestImpl = libtest_mimic::Test<&'static Test>;
-
-#[distributed_slice]
-pub(crate) static NONDESTRUCTIVE_TESTS: [Test] = [..];
-#[distributed_slice]
-pub(crate) static DESTRUCTIVE_TESTS: [Test] = [..];
+pub(crate) type TestImpl = libtest_mimic::Test<TestFn>;
 
 /// Run command and assert that its stderr contains pat
 pub(crate) fn cmd_fails_with<C: BorrowMut<Command>>(mut c: C, pat: &str) -> Result<()> {