A first version has been produced with central tumor locations that seems to work out. Further refinement of the module comming in next push

The midline model was further expanded to have similar funcitonalities as the old model. Additionally, the code style was made more conformal with the bilateral module.
Right now the code is not functional.

The new modality sync makes sure that both models stay updated

New key assignment for midline model where 'ipsi' is removed to ensure correct assignment

fixed the non mixture midline extension model and added documentation

Related: #74

We have added a mixin class that allows the delegation and
synchronization of attributes. This may replace the convoluted and
unreadable callback functions we used to sync some properties

Related: #74

Two new helper function in relation to getting and setting params.

The API of all `get_params()` methods is now nice and uniform, allowing
arbitrary chaining of these methods.

BREAKING CHANGE: The `get_params()` methods don't accept the `param`
argument anymore.

The API of all `set_params()` methods is now nice and uniform,
allowing arbitrary chaining of these methods.

BREAKING CHANGE: The `assign_params()` method has been removed and some
`set_params()` methods work differently than before.

It does make sense to "use up" the positional arguments one by one in
the `set_params()` methods, but doing the same thing with keyword
arguments is pointless, difficult and error prone.

BREAKING CHANGE: `set_params()` only returns one tuple of floats.

In the `Edge` class, the `name` property is replaced by a function
`get_name()` that is more flexible and allows us to have edge names
without underscores when we need it.

BREAKING CHANGE: `Edge.name` is replaced by `Edge.get_name()`

This will once again manage the symmetry of the `Bilateral` class's
different ipsi- and contralateral attributes.

Instead of a dict that holds the T-stages and corresponding
distributions over diagnose times, this implements them as a composite
pattern. This replaces the dict-like API entirely with methods. This has
several advantages:
1. It is more explicit and thus more readable
2. The composite pattern is designed to work naturally with tree-like
structures, which we have here when dealing with bilateral models.
3. This separates a lot of the logic into separate abstract classes,
further separating concerns.

BREAKING CHANGES: The old API of setting and getting distributions will
not work anymore.

Instead of a dict that holds the names and corresponding
sens/spec for diagnostic modalities, this implements them as a composite
pattern. This replaces the dict-like API entirely with methods. This has
several advantages:
1. It is more explicit and thus more readable
2. The composite pattern is designed to work naturally with tree-like
structures, which we have here when dealing with bilateral models.
3. This separates a lot of the logic into separate abstract classes,
further separating concerns.

BREAKING CHANGES: The old API of setting and getting modalities will
not work anymore.

I added an abstract base class from which all model-like classes should
inherit. It defines all the methods that need to be present in a model.

The idea behind this is that any subclass of this can be part of a
composite that correctly delegates getting/setting parameters,
diagnose time distributions, and modalities.

Use the new composite pattern for the distribution over diagnose times
and modalities.

BREAKING CHANGE: `Unilateral` has no attributes `modalities` or
`diag_time_dists` anymore.

Also, add a `clear_modalities()` and a `clear_distributions()` method to
the respective composites.

This removed the dedicated `parameter_hash()` method.

Instead of using this weird `arg0_cache` for the observation and
transition matrix, I use the necessary arguments only, which are all
hashable now.

The `max_time` is now correctly accessed and set. Also, the distribution
params are not used up by synched distributions, but only by the
distributions in composite leafs.

The way the likelihood was defined, it did not actually play nicely with
how the emcee package works. This is now fixed.

… 'dev'

This unexpectedly turned out to be another large refactoring of much
of the codebase...

However, now the management of the modalities and the distributions
over diagnose times both are implemented using a composite pattern.
This also decouples the respective logics from the individual models.
Eventually, this should also allow one to build mixtures of these
models and just use setters and getters of diagnose distributions and
modalities without much changes.

Another big feature of this merge is that the midline model is now
back again! Though it is still largely untested and it is still
lacking the treatment of the midline extension as a random variable.

Fixes: #74

The `Unilateral, `Bilateral`, and `Midline` model now all have the six
methods `set_tumor_spread_params`, `set_lnl_spread_params`,
`set_spread_params`, `set_params`, `get_tumor_spread_params`,
`get_lnl_spread_params`, `get_spread_params`, and `get_params`.

The midline evolution that Lars Widmer worked on is now reimplemented.
However, although this implementation is analogous to the one used in
previsou version of the code and should thus work, it is still untested
at this point.

The new helper function`draw_diagnoses` is a re-implementation of the
`Unilateral` class's method with the same name for easier reusing.

This is implemented differently than before: If data with unknown
midline extension is added, it gets loaded into an attribute named
`unknown`, which is a `Bilateral` model only used to store that data and
generate diagnose matrices.

Some bugs in the method for drawing synthetic patients from the
`Midline` were fixed. This seems to be working now.

The parameters of call signatures now each get their own line, making it
much more readable.