Implement derivation
Generic association lists. Not very useful yet.
Beta: evalTermP evaluates a term containing Variables

Using an association list
A bit of documentation and some trivial transformations
Added abs() clause
Merge branches 'pu/parse', 'pu/eval', 'pu/simplify' and 'pu/derivate' into next

Test release
Changed simplify's behavior

By introducing simplify as new function and renaming the old simplify
function into simplifyOnce we can avoid infinite recursion; simplifyOnce
calls the specific function for a term (e.g. simplifySum) which
transforms it by one step. simplify calls simplifyOnce as long as
simplifyOnce delivers a term different from the one before
(like `until simplifiedTerm == term; simplify (simplifyOnce term)`)

This commit introduces some new rules as well.
Beta: Factor out common factors in products

Simplify now transforms a term like
    b * a * c + b * c * d
to
    b * c * (a + d)

It's not fully functional yet.
Replaced (==) by elem

well, that's awkward...
Moved fromMb to Symmath.Util
Prototype of a simple function value table function
Beta: Function value table.

TODO:
    - Align the table as Perl would do it with its formats.
    - Allow rounding to more or less decimals than 3
Miscellaneous changes

- Fixed bug: x * (y * y) was transformed to the non-resolvable product
(x * y) * y without checking if (y * y) could have been simplified.
- New rule: x * x^2 => x^3
- Variables go before other terms when sorting products
Fixed wrong clause order in simplifyFrac
Unnecessary clause removed; some cosmetics
Added unit test for simplify

From the next release on, the testing "infrastructure" consisting of the
makefile and the template in TestSimplify.hs can/should be used to cover
all Symmath functions. Who wants to be Testing Engineer?
Fixed infinite recursion in some scenarios
Better clause structur in simplifySum. Fixed regression
Better product reducer.

Simplify had difficulties with terms like (a * c) * a * (b * c * d). Those
difficulties are solved now by a new algorithm which linearizes products
(similar like we do when we factor out); It transforms the term above to list of
factors [a,c,a,b,c,d], sorts them [a,a,b,c,c,d], groups the result
[[a,a],[b],[c,c],[d]] and then applies a function which transforms such lists of
same elements to powers [a^2,b,c^2,d]. Finally, listToProd converts this list
back to a product.
Putting the new reducer in another cleanup function.

This allows us to remove 9 other explicit rules.