Creates basic frameword for developing a LatinVerb

Migrates legacy tests and builds the TDD harness by which the new and improved
LatinVerb will be developed.  Creates into a gem framework, which was not done
in the previous release.
Adds verification of conversion of LaTeX-style definition strings

Uses Steven G. Harms macronconversions library to convert strings defining the
paradigmatic verbs that use the LaTeX-style definition to convert it into
strings that make use of the UTF-8 characters.
Adds verb classification class method and tests.
Adds a basic verb validity test.  Corrected stupid typo.
Changes the class method eval semantics.
Adds function for accessing classification and a short vesion too.
Adds support for initialization string as array.
Adds preliminary stub for catching and hanling irregular verbs
Adds functionality for caluclating stems from present active infinitives.
Adds custom exceptions module
Adds improved error handling and derives a stem

Commit adds support for a 'stem' function, which is a usable base that can be
processed to form conjugated nodes.

Custom exceptions added in the previous commit are used to create errors when
testing and processing strings that code for irregular verbs.
Adds participial stem calculaion and strengthens irregular verb testing
Adds dependency on Steven G. Harms' verbvector library.

A LatinVerb can be conceived as a state defined by four principal parts whose
activites are defined by ~121 methods or "vectors."  Writing out these method
names by hand is incredibly tedious, nevertheless, the ability to respond_to
when queried is very useful.

Further, these names can be used as proxies from larger clusters.  Verbvector
suggests clustering on tense.  Therefore, while a given vector may not, in the
code, respond but rather delegates to its "cluster" parent, it simulates as if
it does respond to all the vectors that one might logically deduce from the
grammatical structures of the Latin.
Neatens up interfaces with the verbvector library
Creates metaprogrammatic "masking" for Verbgenerator methods

I changed verbgenerator to generate methods that are prefixed with the
language name.  As such, the Module that that code generates now has nothing
but methods beginning with @language_.  This means that within a given *Verb,
you have to call *_some_verb_vector.

But this does not make any sense.  You would not say
LatinVerb#latin_do_something, of course.  The great benefit is that precisely
because this makes no sense, you will say LatinVerb#do_something /and that
will trigger method_missing/ and that is /exactly what you want/.  With
method_missing , you gain the ability to parse apart the vector because you
have the name of the method as a symbol.

Now you can ask for a cluster method, based on the match of the method_missing
symbol and then get some subsection of data with the part that doesn't match
the cluster.  That is:

:active_voice_indicative_mood_imperfect_tense_singular_number_third_person

can now be caught and matched with:

:active_voice_indicative_mood_imperfect_tense(singular_number_third_person)
 #=> aresult

Effectively this is a gigantic hack around Ruby not having a method_called()
method (probably generally wise, but...).

Changes:
  - Given the importance of metaprogramming, it seemed sensible to break
    method_missing and respond_to into their own file
  - Uses more descriptive variable names for the Verbvector-generated data
    structures
  - Provides protections around the metaprogramming behavior in the initialize
    routine for the LatinVerb class.  This makes sure cluster methods are
    /not/ defined in the Verbvector generator, *but* that their sub-vectors
    /are/.
Added constants for suffixes.
Breaks out exhaustive tests into separate testlibs
Standardized encoding comment.
Corrected constant notation
Corrected metaprogramming logic