Performance improvements and, I think, I simplifications to the
implementation of compound model evaluation:

1) Changed the call signature of the functions that are chained together
   when creating the sequence of operations in a compound model eval.
   Previously this just took an *args consisting of the model inputs,
   but now it takes just two arguments: ``inputs`` which is a tuple of
   the model inputs, and ``params`` which is actually an iterator of all
   the parameters for all the submodels--each submodel's evaluate picks
   off some parameters using islice. (This algorithm could use better
   explanation in the code, in general.)
2) This change means that the parameter values do not need to be "baked"
   into the function chain, and can be passed in later.  This means that
   the expression tree only needs to be walked once, and the resulting
   call chain can be saved off later for future evaluates().  Some quick
   testing suggests this will speed up evaluate roughly 4 times
   (possibly more depending on the complexity of the expression), which
   will be very useful for making fitting more efficient (once I can get
   back to finishing my improvements to the fitter implementation).
3) The change in the operator lambda signatures, as well as a few other
   tweaks here and there reduced the number of tuple packaing/unpacking
   operations.  These don't have enormous overhead on their own, but it
   can't hurt.