In the processes the postTimestep is also used to store local variables
for the next time step. Computation of secondary variables and other
local quantities is done in the computeSecondaryVariables.
Changing the order prevents that values from last iteration (not from
final solution) are stored for the next timestep.

Interface and time loop changes. Processes are in the
next commit.

getRelativeChangeFromPreviousTimestep() was directly
calling the computeRelativeChangeFromPreviousTimestep().

This simplifies the TimeDiscretization interface:
pushState and popState are no longer needed. The corresponding
copies are done in the time loop.
Since the previous time step solution is no longer stored
in the time discretization, it is passed to all required
functions like assemble, getRHS and the like.

This are all but backward Euler.
The few testcases in H2-pp were updated to backward Euler
without loss of accuracy.

 - All processes using a Newton scheme are discretized
for the backward Euler scheme only. They are not usable
with other time discretizations.
 - Greatly simplifies code maintenance in this part.

To access the solution values a dof tables are passed
too.

Foob = out-of-balance forces.

preTimestep now accepts a vector of solution together with
a process_id.
In postTimestep only the vector of solutions has been changed.

_solutions_of_coupled_processes member.

Semantically identical to vector of references.

Pass process_id to FEM::assemble calls.

Avoid local variables `process_id' when looping over
all processes.
Move numbering of the processes to the ProcessData ctor.

Drop dt where used together with it's updates etc.

Avoids "good" state by chance.

Equal for both, the staggered and the monolithic
cases.

Unifies the monolithic and staggered cases.

The function can decide this on its own now.

This is similar to the staggered scheme implementation.

Avoid use of independent process_id variable in the loop,
reuse the process_data.process_id.