* Handle explicit vs implicit interfaces

Partially done. Needs alot of testing. Some of the more exotic stuff
that C# can do is not handled. eg.

interface IFoo {
	void Blah ();
}

class A {
	void Blah ();
}

class B : A, IFoo {
}

C# makes a stub in B that calls A.Blah in order to implement IFoo.Blah

* Handle printing out constants
** String/char consts
Mostly done. The only work we need is to escape stuff:

	class X {
		const string Z = "\t";
	}

** Numerical constants
Integers generally work. Need to check things like decimal.

** Enumeration constants
Needs alot of work. We should print out

	const MyEnum x = MyEnum.Y

	const MyFlags z = MyFlags.X | MyFlags.Y

etc.

* Enumerations
Need to print out the values. This should idealy be done in the most
sane way possible:
     * In the case where values are not needed (eg, sequential from
     1...n), don't print out the enumeration values.
     * For flags enums, values of members that are 2^n would be
     printed as (1 << n). Values that are combinations of other values
     would be printed as MyFlags.X | MyFlags.Y

The goals here are (in order)
    * To print something that will compiler correctly (with the same
    values as the origional)
    * To print something that is as clean/humanly readable/looks like
    it was written by a person as possible.

* Generics
** Console Parsing
It is a PITA to type:

monop2 'System.Collections.Generic.List`1'

We should allow people to type System.Collections.Generic.List and
have it guess the arity. For something like Nullable where it is
overloaded by arity, we'd have to print a message.

* Console Coloring
It'd be cool to have syntax highlighting for the console. Some
examples of this are:

	 * colorgcc
	 * ls --color=auto

* Attributes
.NET 2.0 has support for getting the data that custom attributes
have. This would allow us to correctly print stuff out. Probably want
this to be a command line option.