now we have 4 passes: fast_inst_sel, fast_reg_alloc, followed
by slow_inst_sel and slow_reg_alloc. This might make the
compilation pipeline more linear

Creaation and destruction of MuVM, MuCtx and MuIRBuilder. Now the
`mvm->new_context`, `ctx->new_ir_builder`, `ctx->close_context` and
`b->abort` works. MuVM can also be created via a top-level "C"-style
exported function `mu_fastimpl_new()` so that in theory, it can be used
in C programs.

internal id and machine id do not persist during serialization
and restoration. Currently I use fixed ID for machine registers.
But internal id is still generated, this might be a problem in
the future.

Now it is the time to actually implement the public API. This commit
only contains scaffolds so that it compiles, and I can fill in actual
implementations later. Most of them should forward to the actual VM.*
methods (with some adaptations).

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()`.