I was thinking some more about the coverage breakage - I think it actually highlights a bigger problem that our hybrid cargo/cmake build ends up building some rust code multiple times. It usually isn't a big deal and works out ok in the end, but could end up causing subtle problems.

• In any given cargo invocation, it (re-)builds all dependencies in that invocation's target tree. The generated artifacts have mangled names that, IIUC, incorporate the version of the compiler, the version of the dependency, what features are enabled, and extra flags passed through env variables, etc.
• For our Rust crates that link to C libraries, we pass extra flags via env variables for those to link correctly. When multiple crates with the same dependency are compiled, they end up generating different versions of that compiled dependency, since the flags were different. (Even though the flags being passed, -L, and -l shouldn't actually change the final static libraries)
• Usually the linker manages to deduplicate correctly in the final link step, but it's not in the coverage build. (I have some ideas as to why, elided for relative brevity)
• I think there could end up being other subtle issues e.g. if a multiply-compiled-and-linked dependency does end up in the final shadow executable or shadow-shim library multiple times, particularly if it uses any globals (such as thread-locals).

I think this problem all goes away if we build all of our Rust code in a single cargo invocation. In that case, everything is built with the same cargo env variables, getting rid of some of the false duplication.

For that to work, we need to move the knowledge of what linker flags to use for which crates from the cargo invocations in cmake, into cargo build scripts for each crate.

Right now that would be tricky, since cmake is responsible for building some of the C libraries. It's hard to "hard code" the right linker flags in the Rust build scripts.

We can fix that by wrapping each C library in a Rust crate. That moves the responsibility for managing and propagating linker flags from cmake to cargo.

So that's what I'm doing here. This PR currently:

• Transforms each C library being linked into shadow or libshadow-shim.so into a Rust crate. Currently these are just ~empty Rust libraries, with a build script describing how to compile the C files. This also has the benefit of putting us in a position where we could incrementally start moving code from C to Rust within each of these libraries.
• From cmake only makes a single cargo build invocation to build all of the relevant Rust code. In addition to avoiding false duplication due to different env variables, this allows the whole Rust build to use a single target directory, which should allow it do better caching/reuse.
• I've also (partly) moved the bindgen invocations from cmake into the Rust build scripts. They are kept optional by putting them behind an optional "feature". This is semi-orthogonal, but makes a little more sense since we're already using cargo build scripts at this point, and moves further to driving the build of shadow itself from cargo instead of cmake.

I'm still doing some cleanup. In particular:

• One downside is that the final link steps for shadow and the shim are still in cmake, and currently the knowledge of exactly which libraries need to be included in that link is hard-coded. I don't see an easy way to extract it from cargo. It's not that bad, but I'm going to try moving these to Rust as well, which should resolve it.
• The cbindgen invocations are still in cmake. Might as well move those into the build script too if we're moving the bindgen invocations there.

If we do both of those, pretty much the whole shadow build will be managed by Cargo, and we'll just be using cmake to invoke cargo and compile and run the tests.

I started thinking more about whether we could do 1 big cargo build instead of using it to build i was curious about how hard it is to have Cargo compile C code for you; it turns out it's actually pretty nice. it ended up spiraling into moving most of the shadow build from cmake to cargo