Changed the 'Exec' monad to make use of 'Control.Monad.State.StateT'
instead of 'Control.Monad.Reader.ReaderT', and moved every store of
variables into the 'Dao.Interpreter.ExecUnit' out of their respective
'Data.IORef.IORefs' or 'Control.Concurrent.MVar's. Now variable stores
are updated directly within the stateful 'Dao.Interpreter.ExecUnit'.

Doing this resulted in a cascade of other necessary changes.

1. All of the functions relating to updating variables had to be changed
to make use of the new 'Dao.Interpreter.ObjectLens' class -- a class
inspired by, and similar in function to, the now famous (in the Haskell
world) "lens" package. Although the 'Dao.Interpreter.ObjectLens' class
makes use of state monads throughout, and is specially designed to be
most suitable for the "Dao.Interpreter".

2. The 'Dao.Interpreter.ObjectLens' class has had to be modified such
that the 'Dao.Interpreter.updateIndex' function now returns the @(Maybe
Object)@ value when the update is successful, where as before, the
return value was the Haskell void value ().

3. Variable stores do not need to instantiate the
'Dao.Interpreter.objectFMap' function, so this function has been moved
into it's own class called 'Dao.Interpreter.ObjectFunctor', although
'Dao.Interpreter.ObjectFunctor' continues to make use of the
'Dao.Interpreter.ObjectFocus' monad used by the
'Dao.Interpreter.ObjectLens' class.

4. Several APIs have been renamed to better describe their lens-like
functionality.

5. Now that the 'Dao.Interpreter.Exec' monad can arbitrarily modify any
value in the 'Dao.Interpreter.ExecUnit', this simplifies the mechanism
for executing query strings. So much of the old machinery has been
removed, leaving only a few functions for executing string queries. Most
of these functions have been moved out of the "Dao" module and back into
the "Dao.Interpreter" module so the built-in string query functions can
be defined in "Dao.Interpreter", and a more object-oriented set of data
types for evaluating string queries have been introduced. This is an
improvement over the previous mechanism which placed a family of
built-in functions all starting with the name "do()" or "doAll()". Now,
the "do()" and "doAll()" functions are evaluated in object-oriented
fashion: by first defining a query object 'q', and using dot-notation to
call the "do()" function on 'q' like so: 'q.do("query")'.

7. Updated the 'Dao.Interpreter.DaoFunc' API so functions now work more
like object methods in an object oriented language like C++ or Java,
where the value of the "this" variable is passed as an argument to the
function, along with a list of [Object] arguments.

8. Defined new API's for the 'DaoToStruct' and 'DaoFromStruct' monads
for defining constant functions so these functions can be called using
the object-oriented dot notation: 'Dao.Interpreter.objMethod' and
'Dao.Interpreter.method'.