Add ToString() methods
Merge remote-tracking branch 'tim/dot-net-methods'
Speed up unit tests: only initialize builtins once

No need to initialize Builtins.lisp once per test. Once per TestFixture will do!
Add support for string literals

Simple, non-escaped string literals added to the lexer/parser.
Add backslash escape for string literals

This has been done in the most hacky way... Ideally, there would be some way to
leverage C# string literal escaping logic....
Support escape of non-literal characters too

Use Regex.Unescape to unescape string literals from the lexer
Add support for \t, \n etc. to string literals
Use quoted string literals in .Net

Now that we have quoted string literals, don't use quoted symbols as a proxy
Remove unneeded symbol code
Allow each .lisp test file to have a setup

Each .lisp file now has a "setup" element and a "tests" element.
The "setup" allows arbitrary lisp code to be executed once before
all of the tests are run.

This allows us to not have "mscorlib" in builtins.lisp, and also
allows more sophisticated tests to be written at a later point
without requiring more and more logic to be added to builtins.lisp.
Add a unit test showing problem with .Net methods

The .Net methods were implemented by explicitly using an evaluator
to evaluate each argument rather than delegating this to the calling
evaluator.

The problem with this is that it breaks continuations. Unit test gives
an example of how this could be a problem: constructing an argument
for a .Net method call which happens to raise a continuation
only lets the continuation escape to the site of the .Net method call.
Add string->symbol, symbol->string
Implement instance methods as a macro

"(.method target arg1 arg2 ...)" is now a macro which is expanded into
"(invoke-instance target "method" (list arg1 arg2 ...))"

Doing things this way we no longer require "." to be a special "FExpression".
This solves all of the evaluator problems (that broke continuations
for .Net methods). It could have been solved by changing the "ClrSymbol"
FExpression to obey all the rules - but this way was easier.

This reflection ability is in the "standard" environment - but it's also
possible to create a "sandbox" environment that cannot arbitrarily call
into reflection.

All that's left now is modify how static methods will work.

Simplest way is probably to expose all static methods in an assembly
whenever "ref" is used...
Implement static methods

Implemented support for static methods by using the "ref" command to "define"
symbols for all static methods in an assembly.

This provides a consistent resolution to the question of what should happen
if "ref" is invoked inside a nested scope (e.g. inside a function).
static methods are first class functions
Re-arrange invoke-instance for currying

invoke-instance is much more amenable to use in currying
when the "method" name comes first and the instance second.
Improve the syntax for refering to instance methods

Not *quite* ideal yet, but we're nearly close to "intuitive"
syntax for .Net method integration.
Add a comment detailing plan of action for "dot"
Implement the "dot" operator properly

Enhanced the reader and the parser so that
(.Equals 1 2) is read in as
((dot Equals) 1 2).

Now, "dot" can be a macro which invokes the appropriate "instance method".
This now makes ".Equals" and the like "just work" particularly for using
.Net methods as higher-order functions for things like:

(map .ToString '(1 2 3 4))
Add multi-argument higher order instance example