Merged.

I made some tests with the following configurations:

1) --heuristic "h=lmcut()" --search "astar(h)"
2) --heuristic "h=lmcut()" --search "astar(max(h))"
3) --heuristic "h=lmcut()" --search "astar(max(h, h))"
4) --heuristic "h=lmcut()" --search "astar(max(h, hmax(), goalcount(),
                                     lmcount(lm_rhw(),admissible=true)))"

They all seem to work properly. In particular, 1) and 2) behave very similarly
as expected. Setting 3) highlights the problem with the current approach that
we'll need to fix eventually: this evaluates the heuristics twice and hence
takes twice as much time. The evaluator approach will fix that eventually, but
we'll have to fix the search algorithms first.

Reopening this to merge Erez's code as well (as IPCMaxHeuristic) since
evaluators cannot be used together with A* in the way we want at the moment.
This has to be resolved properly in some other way eventually, but for now we'll
need the heuristic-based solution for the IPC.

I reviewed the changes and they look fine to me. The only thing I do not fully
understand is the plugin mechanism. Malte, maybe you could explain it to me
after the IPC deadline?

I mark the issue as resolved.

Actually, I have changed my mind and merged my code already, since whether or
not it works, it should be at least as good as what we had previously. Still, if
someone could review the issue181 changes, that would be great.

I've implemented my own version of this, using evaluators. I've pushed it to the
IPC repository, but not yet merged (it's in the issue181 branch), since it'd be
good if someone else could take a look at this (relevant classes:
CombiningEvaluator, SumEvaluator, MaxEvaluator).

I observed some strange output while testing this (see issue182), but that
doesn't seem to be new; it already happens with the old sum evaluator code.

Maybe you didn't implement get_involved_heuristics? That could cause
inadmissibility later on during search due to LM information not being updated.

I tried that before, but it caused some issues (such as inadmissibility).
However, I might have done something wrong, so I will look into this approach 
again tomorrow.

Adding Gabi as our resident evaluator expert.

I think the implementation is on the wrong track; it should be more along the
lines of how sum_evaluator works.

Specifically:
1) I think we should be able to perform the max of scalar evaluators, not
   just heuristics. For example, we may want to compute the max(h1+h2, h1+h3),
   but the current implementation won't let us do that because h1+h2 is not
   a heuristic.
2) I don't think we should call reach_state and evaluate for the component
   heuristics/evaluators. Rather, we should implement get_involved_heuristics
   (or what that was called) and let it do a magic. Otherwise, in situations
   like alt(f, h, max(f, h)), some heuristics will be recomputed and reach_state
   be implemented multiple times.

pushed to my repository

Implement Max of several heuristics