- Replace throwing Errors with InstantiationErors in unit, page and
  section in strictInstantiation mode

In Player-context the constructors are to fail, when the given 
properties are not exactly as expected. Therefoore they are validated. 
When this validation fails, an environment variable is checked to 
determine if the element should be created anyway with defaults. This 
switch is off in player-context. But the Editor is not so strict and can 
create elements with incomplete parameters.

There is also a new VersionManager which checks given unit definitions 
for version-validity. Upon failing this check Player and Editor show 
error messages.
The Editor accepts a certain unit definition version, but shows a 
warning.

The Editor checks units for invalid references after loading. If any are 
found, they are removed and an info-panel is shown.

- Model constructors (elements, unit, page, section) now have a 
dedicated parameter, which makes sure all properties are set and valid. 
This way the player can instantiate models without having to interpret 
the values. Any interpretation is done only by the editor, which now is 
solely responsible for creating defaults/blueprints for new elements. 
Models can no longer be created by incomplete paramaters.

- Also refactor Stylings to have sub groups for common styles

Also restructure files containing interfaces.

#453

Measure holds the value and a unit for CSS properties.

- remove ID handling from model classes. This is now done by the editor 
itself (mainly unit service).
- Rename and move IDManager to editor as IDService

Remove 'any's be adding proper types and using 'never'.

- problem with nullish values

Page needs to be a partial as it is only the blueprint.

Now properly finds all normal and simple drop lists.
This is achieved by a new method of unit all it's sub-components, which 
returns all contained elements with and optional type filter.

Also improve (still not very pretty) styling of the drop list props 
panel.

#260 #259

- Elements initialize their fields explicitly and not with
  Object.assign, since Object.assign also assigns
  (and therefore overwrites) parent fields.
- IDService is no longer an Angular service but a basic singleton. This
  allows to use it in classes.
- The IDManager can be optionally passed to unit and element
  constructors. When present the elements check and fix their given ID
  when created.
  This way elements can be created without depending on the external
  IDManager but also with the dependency.
- ElementFactory is no longer used to create elements. Those are now
  either created directly via 'new' or via the Section, which knows the
  different element types.

Elements read as classes were overwritten by the plain objects passed to 
the constructors.

This way elements can handle their logic themselves without having to
rely on outside utility classes.

Also restructure files in common in a more logical way.

This removes all the classes and goes back to simple interfaces for
unit, pages etc and all elements. This makes creating them easier and
cleaner.
Things like specific needs when setting element properties and most
importantly compatibility handling is done by a special service module,
that knows all the elements and how to repair old their potentially
outdated definitions.

Variable naming, reorder imports etc.

Generally only the editor needs to generate new IDs. Before there was
need to have it in common because some elements (like compound elements)
needed to generte new Elements including IDs.
Now all ID stuff is handled by the UnitService and the elements classes
are handed the fully built elements. Unfortunately this means that some
logic has to move back from classes into the UnitService. To un-bloat
the UnitService a (and in the future some more) helper class is created
for this logic.

The most important thing is, that the UIElement no longer generates
an ID when created. The ID has to be created before and passed to the
constructor.

- Remove interfaces
- Add classes for all elements as well as unit, page and section
- 2 intermediate interfaces are kept. They dont constituate a viable 
object but only additional properties, like background-color. Those can 
be added as interface to all elements. Initialisation has to be done by 
the element itself though and not by some constructor higher up.