Modified the main program so that when launching the command line
interface executable program, the copyright is no longer printed to
standard out. To see the copyright info, you can print it out with
the "--version" parameter, and with the ":license" command.
Bug fix: actually not a fix, just a temporary bandage. Side effects,
specifically modifications to global variables made by functions
evaluated from the top level are not persistent, changes to the global
variables made during function evaluation are lost once the function
returns. The 'Dao.Interpreter.referenceLookup' function is calling
'Dao.Interpeter.updateIndex' which creates a temporary copy of the
'Dao.Interpreter.GlobalStore', the function is evaluated makes updates
to global variables in the 'Dao.Interpreter.GlobalStore' in the
'Dao.Interpreter.ExecUnit', 'Dao.Interpreter.updateIndex' replaces the
changes made during function evaluation with the temporary copy of the
'GlobalStore' on the assumption that the function object itself was the
only object updated (which it was not) and that the update occurred
essentially atomically (which it did not as function evaluation performs
many evaluation steps).

My current solution is to look ahead at the kind of object
'Dao.Interpreter.Reference' value being looked-up and if it is a
function call, do not perform an update. This is a terrible solution,
because whether or not an update occurs should be defined in the
instance of 'Dao.Interpreter.ObjectLens' for that particular storage
object. I will need to work on this later
Bug fix: rules with multiple patterns were being constructed such that
each pattern was concatenated, rather than each pattern being converted
to a glob and all globs being unioned together. This has been fixed so
now the rule expressions construct rules in compliance with the official
Dao programming language official specification that exists in my
imagination.

To fix this bug, I instantiated 'Dao.Interpreter.PatternRule' into the
'Dao.Interpreter.Executable' class such that
'Dao.Interpreter.execute'ing a 'Dao.Interpreter.PatternRule' will
construct a pattern tree. This

Also, the other day I had eliminated the 'Dao.Interpreter.RefReducible'
class and hand-coded the special cases where that class was necessary.
But now, rather than hand coding, I have a new solution to the problem
of deciding when to evaluate a 'Dao.Interpreter.AST.AssignExpr' to a
'Dao.Interpreter.Reference' literal, and when to dereference that
'Dao.Interpreter.Reference' literal and return the value at the address
to which the 'Dao.Interpreter.Reference' is pointing.

The solution is to create a newtype wrapper for
'Dao.Interpreter.AST.AssignExpr' called
'Dao.Interpreter.DerefAssignExpr' which, when
'Dao.Interpreter.execute'd will automatically do the right thing,
dereferencing 'Dao.Interpreter.Reference' values to exactly one layer of
indirection, or zero layers if execution of the
'Dao.Interpreter.AST.AssignExpr' returned a result of an assignment
rather than a literal expression.