Async transformation

This is a first implementation of #1881, still working in progress.
A number of `TODO`'s are left in the patch, those are questions about coding style, structures, naming convention etc. 

This patches introduces a new suffix: `__async` in the library, which marks the functions as async. If any async function is used, the async transformation routine will be triggered. `shell.js` is modified to take care of `_main`

Async functions must take a callback function as its _1st_ argument, I chose the first instead of the last because of the possibility of optional arguments. It is possible to extend to support arbitrary index. It may not work with dynamic linking unless special declaration.

An example test case has been added.

Currently it doesn't work with ASM.js or relooper. I'm not sure about relooper, but with more efforts it should work with ASM.js &mdash; unless the type of the callback must be determined in ASM.js

The currently implementation is still kind of hacky, in `analyzer.js` and `jsifier.js`, I tried to hijack existing data structure, by defining the `async` property (and also a few others). I guess this is better than changing intertype, (e.g. change `call` to `async_call`).

**[Update]**: The functions and variables for async functions are 'outside' the existing data structure which is parsed from LLVM, I'm not sure if this is good or not. Good part is that these are after all not a part of the original code, and the bad part is that these variables/functions may be easily ignored or broken when implementing new features. 

Please review and leave comments if anything is inappropriate, and I'll make modifications accordingly.


Issues:

- Exception are not handled right now, we can support this by maintaining our own asyn stack and register exception handlers there, like in streamline.js, but not sure if the overhead is too much.
  - ExitStatus cannot be caught - use callback in Module ?
- Since we need a complete call graph to find all async function, it does not work when functions are processed separately(compile in parallel, batch process function lines). Maybe we need a light-weight call-graph analysis in the end of the pre phase or at the beginning fo the funs phase?

- Function pointers are not handled &mdash; it may not be a good idea to mark all of them as async, but if we have to, we can attach attributes to it (e.g. `_main.async = true`)