Found a way to implement handle allocation and dealllocation, and a way
to access MuVM from MuCtx using pointers.

Re-wrote the muapi2rustapi.py script.

Use *const for CStrings and CMuValue.

Set linker flags properly according to the OS.

Tested trap handler callback. It looks like it is easy enough for Rust
to interact with C.

Added linker flags so it will work in Linux.

Test whether the generated stubs are reasonable.

partially serialize compiled function into bootimage

Added the "localtest" directory for testing the API without touching
other modules. (TODO: It could be moved somewhere else, but should not
use src as an extern crate, or it will depend on the entire crate.)

Use CStr for incoming strings from C. CString is for C-style strings
**owned by Rust**.

Added comments at the beginning of api_c.rs and api_bridge.rs to
indicate some parts of the files are generated.

Now the API stubs (__api_impl_stubs.rs) should be ready for use.

TODO: Convert retvals back to C.

Inline the converter functions for minimum cost.

Use debug_assert!

Mark C-facing functions as extern.

Added filler functions to fill-up the C-facing structs with methods.

Now arrays, handles and primitive values can be converted to the
appropriate Rust values.

TODO: Need to forward each function to the concrete api_impl methods,
and convert the return values back to C types. Stubs should be
generated to ease the implementation of high-level methods.

api_bridge.rs will convert low-level C valus to high-level Rust value,
such as CMuValue* -> [&APIMuValue].

fn() is already function pointer type. No need for `*mut fn()`.

going to implement exception

45f4501e3855f6cdfb6b132ceac1f8ec0222cce2

cannot get it work by loading it dynamically. Rust mangles mu runtime
functions in test executable (even if I stated #[no_mangle]), so the
dynamic library cannot call mu runtime functions (symbols not found)

(for blocks created during instruction selection)

cargo test needs ALWAYS run with 1 test thread (RUST_TEST_THREADS=1)