Getting started with a better parser

After reading the RDoc docs a bit closer, I realized that there is way
more power in the type experssions than what I first thought. So I am
going to build in a proper type-checker and parser so that it can be
used with more complex systems.
Duck-typing type-parsing

This is for cases where you want to verify that the argument responds to
some specific message or list of messages.
Code refactor, and improvements to collection typing

I moved the big-ass parsing file into a few smaller files, and updated
the type checker with better checks for collections of mixed types, as
well as fixed-length collections.
Getting started with validating hashes.

This is a simple start to validating hashes. It only does a long-hand
version of it right now, and the short-hand will come soon. Also, you
cannot currently check duck-typing on key and value types
We don't need these as we get them "for free" above.

I really shouldn't be testing implementations anyway...
Short-hand Hash parsing for types
Hash duck-typing

You can now define types for keys and values for hashes as duck-typed
entities. For example:

@param [{ #foo => #bar }] foo ...

Will enforce that param, foo, is a hash whos keys respond to the #foo
method, and whos values respond to the #bar method. It should work for
either/or lists as well:

@param [{ #foo,#bar => #baz,#bing }]