Use statepoints to compute stack roots when invoking koreCollect

[dwightguth]

This PR makes use of the LLVM garbage collection API in order to compute the gc roots on the stack when calling koreCollect.

It operates via the following pieces:

• We extract out "opaque" functions for address space casts and inttoptr and ptrtoint casts, so that the optimizer is not aware of them. This is needed due to limitations in the implementation of garbage collection in LLVM
• We modify the address space of all the garbage collected pointers in the code generation phase to use address space 1
• We invoke the RewriteStatepointsForGC llvm pass on every compilation so that we can generate the statepoint calls themselves
• We create an llvm pass that runs after RewriteStatepointsForGC that emits a global variable that tracks the sort category of every live pointer at every statepoint, so that we know how to relocate it
• We modify koreAlloc functions so that we have typed versions that return specific types, in order to better track the sort category of gc roots
• We add code to parse the stack map when the program starts
• We use libunwind in order to walk the stack and generate a list of all the gc roots during collection
• We remove the parameters to koreCollect since we do not need them to track roots anymore
• We switch to using tailcc instead of fastcc so as to simplify tail call optimization

Generating roots from global variables remains the same as before.

This is rather big, so I'd like multiple sets of eyes on it. Note that I have not yet added new calls to koreCollect at the start of other functions in the llvm backend (like apply_rule and side_condition and eval). I decided to do that in a follow up PR since this is already so large.

Ready for review.

[Baltoli]

One minor stylistic issue but otherwise LGTM