compiler: SImplify et.Cond GC logic

The conditional code was trying to disable GC in the branches as an
extra sanity check. This didn't really work as most of the GC code still
works without the values it was removing.
stdlib: Implement (list?)

This is trivial wrapper around ProperList
stdlib: Fix the external form of large rationals

The C++ iostream library will switch to scientific notation if the value
being displayed is too large. This loses precision and can't be parsed
as a valid Scheme number. Fix by manually setting the precision to a
large number before outputting
Initial basic port support

This implements (current-{input,output,error}-port), (port?),
(input-port?), (output-port?) and lets ports be passed to the existing
output procedures

In C++ this is implemented as a std::ios pointer that is dynamically
cast to either an input or output port when required.

The most complex part of this commit is fixing various (parameterize)
bugs the use of parameterized ports and the newly GCing (write) exposed:

- The planner for (parameterize) cast the parameterize's result value in
  the outer plan writer instead of the inner plan writer. This meant the
  result value cast came before the result value was calculated

- codegen was setting the outer temp value to the exact same IR value as
  the inner temp value which greatly confused the GC calculation logic.
  Switch to using withAliasedTempValue which de-confuses the GC logic.
  This still isn't ideal but lets (parameterize) work for now

- If a dynamic state didn't have any values the cell visitor wouldn't
  visit its parent state at all. This would cause crashes with
  dynamic-wind mixed with parameterize after GC occured

- The runtime was accessing the after procedure of a popped state after
  it had been deleted. This wasn't directly observed causing crashes but
  it was definitely a bug.
Add simple assertion-based test support

This allows the previous pattern of compiling a Scheme program for each
tested value to be replaced with a more *Unit style. The ListSuite is
converted as an example. This has a number of advantages:

- Test definitions are more compact

- It's more natural to inspect the same value in different ways than the
  current method of constructing a list of tested values and passing it
  back

- Related tests can be grouped in a single executable to reduce compiler
  overhead. On OS X at least this is washed out by the increased
  complexity of the test's code. Hopefully this will be mitigated with
  more work on optimising the code generated for the tests and grouping
  more tests together

Closes #8
compiler: Simplify (parameterize)

This simplifies the (parameterize) code and allows the planner/codegen
to more easily optimise (parameterize) because it's no longer treated
similiarly to a conditional branch

- Instead of having ps.Parameterize() contain its inner steps just have
  two separate PushDynamicState and PopDynamicState steps. The previous
  nested structure was based off of a misunderstand of how dynamic
  states worked

- Get rid of ps.NestingStep completely - ps.Cond is the only remained
  nested step