BinOp flags are subsidiary to the main binary operation, so moved after
the BinOptr argument.

In the text form, the NZCV flags are optional, so existing programs
are still valid. In the bundle building API, `new_binop` remain
unchanged, but an additional function `new_binop_with_status` is added,
so existing programs are still valid.

scripts/*.py are modified to adapt the MuBinOpStatus enum type.

Not changing semantics, but changed the wording to make it clearer.

- Provided an object hierarchy of objects in a Mu IR bundle. This
  describes the "has many" and "refers to" relations between things in a
  bundle.

- Clarify what are "top-level entities". Specifically, "functions" are,
  but "function versions" are not. Stopped using "top-level definitions"
  because "definition" is too text-oriented. The API functions create
  entities.

- Stopped using the term "declaring a function", but use "creating a
  function" and "creating a function version" instead. Now "undefined
  function" and "defined function" simply refers to functions with 0
  versions and functions with 1+ versions, respectively.

- Explicitly state the "function version lookup" when a function is
  executed.

- The make_boot_image method is moved to MuCtx because it needs to refer
  to memory locations using handles of IRef types.

- Let global cells be always pinned, and added the get_addr API/CommInst
  to get their addresses.

new_bb: parameter types must be explicit

watchpoint: it has three destinations instead of just an ExcClause

wpbranch: both destinations must be explicit

Given all arguments (including all type arguments, signature arguments
and value arguments), the micro VM always knows how many results an
instruction has.

When it is a C NULL pointer, it behaves as if the initial threadlocal
objref is a Mu NULL ref.

Fixed a bug where the last param of new_thread_nor should be
MuArraySize.

Removed MuIRNodeRefValue to make MuIRNode unique.

muapi.h also includes the common instruction names in the comment after
the macro. Improved the API parser for this purpose.

Now the IR Builder API is also available as common instructions. We keep
muapi.h as the canonical definition, and the semantics of common
instructions maps to that of the API functions.

Improved the annotations in muapi.h so that it is easier to generate
language bindings automatically.

The muapiparser.py is copied from refimpl2 for convenience.

Cast constant macros to their respective types so that they will have
proper sizes and signedness.

MuAtomicRMWOp is renamed to MuAtomicRMWOptr, in order not to confuse
"operator" and "operand".

The new_thread API call is split into two functions, one continues
normally and the other throws exception. This interface will be more
C-style.

It will be convenient if there is a program that parses the muapi.h and
generates language bindings (for Python, Scala, etc.). Some annotations
are added in the muapi.h file to make this process easier. For example,
when passing an array, C functions usually take two parameters: a
pointer and a size. The param:array:sz annotation tells the parser that
the "param" parameter points to an array whose size is determined by the
"sz" parameter. "param:bool" tells the parser that the "int param"
parameter holds a boolean value (non-zero or zero). "param:optional"
tells the parser that the "T* param" parameter may be NULL.

The 'irbuilderref' type is no longer used. 'irnoderef' is the only newly
introduced Mu type. A bundle node now works as a namespace. All other
nodes are children of the bundle node. After a bundle node is loaded
into Mu (or aborted), Mu may de-allocate the bundle node and all of its
children for space efficiency.

The thread-local object reference gives each thread a reference to an
arbitrary object, which can hold thread-local states. New API functions
and new (common) instructions are added. It is also a thread states and
a GC root.

Added MuSeqValue and MuGenRefValue in the muapi.h. Although all MuValue
subtypes are just aliases of void* in the C API, having some annotation
makes the API more readable for the programmer as well as language
binding makers.

- Explicitly say in cmpxchg that "weak" is boolean.
- The signature of the trap handler and the new_thread API are corrected
  so that input parameters are values and output parameters are pointers
  to values.
- In trap handler, the "values" array is now a pointer to a
  client-allocated array. The client is also responsible for freeing it
  by providing a "freer". This is solely for working around the C
  programming language's limitation that "raw arrays (T*) do not know
  how to deallocate themselves". Garbage-collected languages (such as
  Haskell, Java, ...) and ownership-based languages (C++, rust) do not
  have such problems.

This is a typo. It should be sint and uint.

- Updated "frame coursor" related API calls.
- Added #ifndef guards against multiple inclusion.

The nvalues parameter is an output parameter. It should be a pointer.

void has a NULL value. Removed the RETVOID instruciton and the SWAPSTACK
PASS_VOID clause, and the corresponding API that involves PASS_VOID.