Fix multi-module support on OS X
Support varargs in built-in core functions

This commit introduces the first changes necessary for supporting a
variable number of arguments, with the first support showing up in the
built-in functions "+" and "*".

The strategy is as follows:

- At the call site, continue pushing all the arguments to the stack as
  before, but also pass along the number of arguments pushed to the
  stack in %rsi.

- Inside the function body implementation, use the new "gather_varargs"
  function to take a certain number of arguments from the "top" of the
  stack (accounting for the stack frames of "scm_fncall" and the
  function calling "gather_varargs") and package them up into a cons
  list.

- Make "+" and "*" take a cons list as an argument instead of simply two
  numbers, then use "gather_varargs" in their implementation.

In attempting to support this, I encountered a number of bugs that
previously existed but were not being exposed earlier (all of these have
been fixed):

- All the arguments to a function call had their "codegen" method
  called, and the result was pushed onto the stack. For comments nodes
  in the AST, the "codegen" method did nothing, so the previous argument
  was being pushed onto the stack again! The fix was to filter out the
  comments before codegen'ing the arguments.

- The logic for determining if the stack had to be aligned was actually
  wrong. Previously, the stack was not aligned if it started out aligned
  and we were pushing an even number of arguments. In addition, the
  stack should not be aligned if it did not start out aligned and we are
  pushing an odd number of arguments.

- The "stdlib_*" functions in stdlib.S were not aligning the stack when
  they called into the various C functions they called.
Improper lists

Syntactically, improper lists are used to denote variadic functions, so
the parser needs to support them. They are also used for literal
improper lists.

I implemented the majority of varargs support, but stack alignment is
getting the best of me again. However, I kept the changes I made and
finished off support for improper list literals.
Fix varargs support

Now, user-defined functions can be variadic, and the functionality
works. It turns out the stack alignment logic was quite wrong in many
cases, so I re-worked it heavily to fix it. This allowed varargs to work
correctly.

I haven't tested this with lambdas, but it should work. The caveat is
when we want no positional arguments in a lambda, which requires
slightly modified syntax that will be added later.
Full varargs for lambdas