Moving files around for new go tool
Fixing everything so it will build and test.
adding vector parsing support in liswat
make pair an interface and parse lists properly

* Turn the Pair struct into an interface and make a 'pair'
  implementation that is meant to be used internally.
* The list parsing was broken and did not handle proper
  and improper lists as properly.
taking care of two minor todo items
prevent problems with backing up twice in lexer
More tests for the Cxr() function.
Add doc-comments for Pair interface.
Add test for malformed character sequences.
Adding a TODO item for fixing our errors.
Adding a TODO item to fix nil handling.
Add Atom type to Scheme interpreter.

Interpreter is slowly coming into shape, but need to develop the
continuations support before going further. For now, have Atom which
represents booleans, numbers, strings, characters, and the void type,
which is a placeholder for variables in letrec.
Parse an entire Scheme program into a list.

Add chained Append() to Pair implementation to facilitate the new
parsing of a Scheme program into a chain of pairs.
Ensure the lexer channel is drained properly.

The lexer channel was not being read to completion in many cases and
the goroutine feeding the channel was left hanging indefinitely.
Added a utility function to read from the channel until exhaustion
and adding a comment that all callers of lex() and friends should
use 'defer' to invoke the drain function at some point.
Make Scheme parser errors like those in Tcl.

Improve the LispError implementation so there is an interface and
a default implementation, just as with the Tcl intepreter.
Implement basic Scheme interpreter.

Scheme interpreter supports evaluating an (if ...) and possibly
some of the other basic syntax (e.g. quote, set, begin, define).
Improved the parser a bit with regards to handling lists of a
single pair.
Tests for basic Scheme syntax (e.g. (begin ...)).

Add tests for the basic syntax of Scheme, including if, define,
set!, quote, and begin. Handle nested pairs in the parser.
Minor cleanup for Scheme parser.

* Unfold uselessly nested pairs (e.g. (((if #t 1 2)))).
* Move parseExpr() to the test code, the one place it is used.
Add (append), (cons), and a pair iterator.

* Add built-in procedures append and cons.
* Add a pair iterator for easily walking a chain of Pairs.
Working Scheme interpreter with lambdas.

The Scheme interpreter is now fully operational, in so much as it
only does if, define, set!, quote, begin, and lambda, and has the
builtin procedures append and cons.