Added clone() Method to Functions

Given the memory management scheme we're going to have on the parser, it made
a lot of sense to have a clone() method on the functions as well as the
values so that we can make deep-copies of the parser and it's contents. This
is just a more convenient scheme than trying to know if it's a reference or
what. Everything is a pointer, and all objects have clone(). Simple.
Put a Lock on the value::hash() Method

Given that all the other methods are thread-safe, it just made sense to do the
same to the hash() method. It's simple and effective, and shouldn't get in the
way.
Added More Functions to Base Set

I wanted to be able to have a decent initial set, so I added in the regular
arithmetic set (+, -, *, /) and then added in the comparison operators as
well as the boolean checks (and, or, not) so that we have a pretty decent
initial set to work with. In order to save code, the comparison and binary
tests are really just one class, but an ivar tells it how to process the
data for the type of test it's doing. This makes the code slightly more
complex, but not too bad, and the savings in lines of code are significant.
Added Evaluation of Values in Functions

I was missing a key component in the base functions - each argument needed
to be evaluated BEFORE it was tested so that if it happened to be an
expression, it was evaluated before it was used. This isn't a short-cut on
what needs to be calculated - not yet, but it's an important step in making
sure that all sub-trees are being calculated properly.
Added a toString() Method that didn't Lock

I needed to have a "no-lock" version of toString() for a subclass, and so I
just made it like the other no-lock versions. This doesn't really have any
significant overhead, and it makes it possible to get the toString() value
within a locked section of code. Very important at times, it turns out.
Added Timestamp Parser for Timer

In addition to the formatting of timestamps, I needed to have the ability
to turn a string of YYYY-MM-DD HH:MM:SS back into a timestamp for processing.
This was needed for the parser, but it's just nice to have as well.
Added eval() and Boolean Operators

I needed to have the ability to eval() and get a value instance back (as a
copy). So I added that as a locking and no-lock versions. Simple, but it is
going to prove very useful in the expression evaluation in the functions.
Secondly, I added in the boolean operators !, && and || that return standard
bool values so that the logical construction of these values works as you'd
expect. Finally, I had to add the const-ness to the equality/inequality
operators as there was an ambiguity in the compiler as to which one should
be used, and this clears all that up.
Added the Named Constructor

I needed to be able to create a variable with the proper name but without
a value - so I created a new constructor. This makes the parser able to
detect undefined variables and create them with no value, so that the caller
can find out what he needs to provide, and provide it.
Added Tests for Timer's Parsing

I wanted to have tests for the new parsing functions of the timer class, so
I made them. There's a bit of a question about what to use as the date when
you are only given a time, but I'm leaving it at epoch as that's the most
understandable reference point for such a thing.
Created Parser Tests

I needed to add a few tests for the parser so that I could be sure I was
getting the right answers. Turns out, I needed to fix a few things, but that's
what the tests are for, no? In the end, I'm sure things are processing properly
and the expressions are being evaluated properly.
Created a Parser for LKit

I needed to have something that would take a std::string that could come from
about anywhere, and create a language tree of expressions, variables, functions
and the like, that can then be evaluated and the value returned to the caller.
This wasn't too bad, as the language is meant to be pretty simple. I just look
at what's in the stream and go from there.
Updated the README's TODO List

Now that I have the first cut of the parser done, I needed to update the things
I wanted to do next. Certainly the variables and functions need to be able to
be defined, and that's next, but after that, there's still a lot of neat and
fun things to do.
Updated Test Makefile and Exclusion File

With the addition of the two new tests, we needed to update the Makefile as
well as the git ignore file. That's it. Just simple housekeeping.