Start of OS X support

It turns out that on x86-64 architectures, on Windows and OS X, gcc
prepends a leading underscore to all symbol names. This is not the case
for Linux (ELF targets). To support this, all stdlib functions names in
the generated code and in stdlib.s are declared and used via a macro
that conditionally prepends the underscore. This has not been tested on
Windows.

On top of that, on OS X, accessing data, whether local or non-local,
must be done using addressing that's relative to the instruction pointer
(RIP), meaning instructions like:

  mov $varname, %rsi

Must actually look like:

  movq varname(%rip)         , %rsi # local data
  movq varname@GOTPCREL(%rip), %rsi # non-local data via global offset
                                    # table (GOT)

Actually, the latter (access via GOT) is valid even for local data,
though it's possible it's slower and therefore can be optimized. For
simplicity, I always go through the GOT on OS X, and again, a
conditional macro works wonders.

Making these changes, I can get past the linking stage. It looks like
the alignment of the stack during function calls has finally caught up
to me, since it looks like it's required on OS X due to the use of SSE
instructions in built-in functions, so I'll have to implement that.
Luckily, that's something that should be good for all platforms.
Stack alignment for x86-64 OS X

This one was a tough one to fix completely, but the concept is
straightforward:

1. Determine the number of arguments you'll push onto the stack when
   calling a function. This is either all the arguments, in the case
   that you're calling scm_fncall in order to call a function from the
   scheme code, or (usually) none for calls directly into the runtime
   library.

2. Based on the current offset (after having kept track of it via pushes
   and pops), and the number of arguments that will be pushed onto the
   stack, determine if 8 bytes of padding is needed. If so, add that
   padding.

3. If the padding was added, remember to remove it after the function
   call.

4. Wrap all native function calls sequences with code to do 1-3 above.