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.

- Simplified the code logic. Verification is done once in the beginning 
and not on every element.
- Now uses semver to verify and compare version strings

ImportModuleVersion stores the unitDefinitionType of the loaded unit
definition. During the initialization of the unit, the individual
elements can react to the stored value.

Use singleton instance of IdService in UIElement

Now correctly creates child elements for every marker it finds.

Updated the TipTap extensions to use model instead of just the ID.

Also improve interface naming.

- 'hideOtherPages' is not supported by verona api
- 'uninterruptible' is already fulfilled by disabling pause and
progress bar

Refactor MathKeyboardComponent to reduce code size

Is now able to interpret more stuff from the editor. The only thing 
missing are the list styles.

Cloze elements are displayed inline and have no way to show a label.

- Now only has a variable 'document'. This holds the HTML representation
  in an object. This object is enriched with element models.
- Because the the TextEditor extension can neither create multiple
  element instances nor use the IDService to generate their IDs, this
  has to be done afterwards. See ClozeParser.
- The cloze element has rather extensive compatibility handling because
  cloze elements used to save an actual HTML representation. This has to
  be transformed to JSON/object. Therefore we replace the old backslash-
  markers with custom HTML tags. The editor object does this
  transformation. It needs some custom extensions to recognize (and
  don't remove) the HTML tags though.
- Cloze now shows a placeholder text when empty
- The cloze component needs a small pipe to extract text formatting
  options from the paragraph parts.
- For getting the child elements for the player the models have to be
  extracted from the somewhat complex (JSON)document.
- Added some rudimentary interfaces for the TextEditor document format.
- Removed the old ClozePart interface. This is quasi part of the new
  interfaces.

- Improve variable naming for unit definiton type. (version string)
- Use 'iqb-aspect-definition@1.0.0' as value which better communicates
  the purpose of the data.
- Also update the HTML files with the new definition. (Even though it is
  not checked anywhere.)

- Move the method to the unit service, so the proper 
updateElementProperty method can be used.
- Also improve the logic, reducing variables.

This allows elements in dynamic sections to have fixed dimensions.

Some modifications to property panel logic, to show dimension fields and
proper labels.

Only implmented in dropList and button elements.

Variable naming, reorder imports etc.

This makes for cleaner imports.

Was not correctly creating new instances of non-primitive values. Now
uses "JSON.parse(JSON.stringify(element))" for deep copying the element
first.

Also refactor by moving the method to the UnitService, where all ID
handling should take place.

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.

This is meant solely as a cloze child as a representation of a radio 
button functionality.

The given serialized properties may not conform to all UIElement 
properties. They are merely meant as a building plan; they may also 
contain outdated properties which have to be transformed when reading.

Basically a div with border properties as usual.

- Dnd values now have a special type that has an ID, a string and
  another string for an image path.
- A new dialog exists for editing thoe options. Similarly to the likert
  header.

The interaction can now be turned off without hiding the button.

The problem being solved is that compound-sub-elements must not have
all the properties other elements have. For exampe positioning info.
Sub-Elements are positioned inline. To avoid having similar class
inheritance structures for positioned and inline elements, we use
interface. Positioning is done via interface and is therefore optional.

Those optional properties are kept in an object in a variable. This
allows to hide specifics from element classes and removes the need to
initialize all the fields in every class using the interface.
The elements mostly care about their own specific properties anyway.

The same technique is used for font and surface elements. Here we also
don't want to initialize all the styles in every class.

Changing values of element properties works like before. Just set the
property as if it would be a direkt prop of the element. The element
itself puts the value in the currect sub-object (positioningProps,
fontProps etc).

For reading the values there is a similar method, but it is not used
anywhere by now. Since the properties panel operates on the raw values
anyway (refer CombinedProperties) and for element components this would
mean calling a function in the template, which caused change detection
to run the function very often and is therefore bad practice.

Additional notes and refactorings:
- Restructure all files in common. UIElements in the same folder etc.
- Move all interfaces to the UIElement file. This avoids circular
  imports, which would be needed to allow PositionedElement to extend
  UIElement.
- Interface initializers also handle reading values in the old form.
- Add PositionedElement for use in canvas overlays. This is a UIElement
  with guaranteed postionProps.
- Don't export all Material packages from common, only the ones
  used in player and editor. The rest is only used in common and
  does not need to be exported.

This is a native input element which is used in cloze elements. Here 
(sub)elements need to be positioned inline, which is hard to do with 
material components.

Also add a method to all form elements to set their form value, which is 
now only used by the simple text field but may be useful for other 
elements, which don't integrate in material form fields.

The issue here is the alignment if dropLists and text fields. They are 
supposed to be exactly in line with the text which is very complicated 
with Material components, which are heavily nested and contain several 
sub-elements which need to be changed - removing margins, paddings and 
other position related styles.

Min-height should be optional for dynamically positioned elements, as 
you usually don't need it and it causes more problems than it solves. 
Elements with min-height have cause unexpected margins between elements.

As requested by product owner.