alternative implementation of inherited attributes

I started on an experiment with an alternative implementation of
semantic functions of inherited attributes. The idea is to use mutable
vectors to maintain the mapping of children to updated attribute values.
reduce strictness
use criterion 1.0
implementation of inh. attr. using IntMap
symbolic product construction for inherited attributes
extend benchmark to use two inherited attributes
more efficient product of inherited attributes

It uses mergeWithKey instead of unionWith (and three applications of
map).
use new inherited attribute implementation throughout
implemented rewrite AG for alternative graph representation

The implementation is much faster than the one for the simple
representation. Instead of the 75x overhead, we have an overhead of less
than 2x.
rewrite only reachable nodes

I refined the implementation such that unreachable nodes are
discarded (in particular, nodes that become unreachable because of
rewriting).
refactoring
avoid re-computation for rewrite AGs
port rewrite AGs to GraphFreeNonEmpty
benchmarks for the new implementations
generate fresh nodes for AG rewrites
efficient AG rewrite for simple graph representation

I implemented an efficient runRewriteGraph for the simple graph
representation. The implementation allocates nodes for the result graph
on the fly. The new implementation is much faster. It is comparable in
performance with the corresponding implementations for the alternative
graph implementations. However, the alternative graph representations
perform better still.
reduced strictness of runRewriteGraphST
reduce strictness for runRewriteGraphST
benchmarks
context as graph root

Generalise graph representation: instead of a node, the root of a graph
is a context.