- Remove unused variable
- Add typing

- Part of the properties panel for every element (like delete and 
duplicate)
- This allows interacting with elements, generating events and inpect 
their usage. Usually this is unwanted since it might interfere with 
dragging the overlay, but sometimes you want to get a feel for the 
element or check it's contents (GeoGebra for example)

..instead of multiple methods doing almost the same stuff.

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.

Components with bigger scope are put to the component root, canvas, 
props panle and new-element-panel.

Change import paths of CommonModule files in editor and player

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.

Only the overlay can be clicked. This way the statre of the elements can 
not be changed which might be confused for actual value changes. Those 
can still only be done via properties panel.

Unfortunately we need another variable so the cloze elements knows when 
it runs in the editor or not.

Compound elements are now supposed to use overlays for their child
elements. This overlay makes selecting child components (by clicking on
them) and marking them as selected (done by the selection service)
possible.
The SelectionService no longer needs special logic to handle compound
children selection, as they now also have an overlay with the same
interface as normal (canvas) elements.

A few modifications in connected directives are necessary. The now
handle children components in a proper array instead of QueryList.

Likert elements do not have clickable children yet and work a little
differently. This should probably be unitized in the future.

This makes for cleaner imports.

This allows to select elements without clicking them on the canvas, as 
elements may be obstructed or not visible for some reason.

The selection logic is a bit complicated because usually only the 
overlay components are usd for selection which are also the place to 
apply any highlighting on. Here we have to find the component element 
reference from the section. Therefore the double looping 
'getElementComponent' method.

Also when an elements is selected it briefly gets z-index 100 so it is 
moved to the front and visible and manipulatable.

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 reverts commit c71cf1a2.

A new variable is introduced for CompoundComponents: 
"allowClickThrough". With this set components can set their children and 
overlays to allow clicking on child elements or not. In the editor this 
is not wanted as the elements internal structure is different and the 
resulting event target can not be reliably styled. There we need the 
(span) overlay.
In the player though elements should be clickable as usual. The player 
can completely ignore this setting as it is on true (allowing clicking) 
by default.

Need to bubble the event further up to where there is a section 
reference.

Was not correctly setting the pointer event for ClozeComponents.

This uses a special event fired only by ClozeComponent, but potentially 
future compound elements as well.
The selection service gets a special method bypassing the usual 
selection logic and just firing the selection event for the props panel.

This structure moves closer to the structure template the team decided
on. Components and services are kept in dedicated folders instead of
following the logical code structure. This is still not the case here as
the unit-view component is still nested, but it's closer.

All elements now use the elementValueChanged event. Also
formValueChanged is changed.

This change mainly helps the editor.
The idea is to make the element components have the correct value of
their model and don't rely on the formcontrol value. The formcontrol
can be hard to manipulate, especially in compound elements. Setting
the model value is way easier.

The formcontrols are kept and should not interfere.

* Remove FormService Injection
* Move FormService and form types to player
* Move interface ValueChangeElement to uI-element.ts
* Use interface InputElementValue instead of
string | number | boolean | null

Should at least be in util folder. And since it is imilar functionality 
to the unit factory it is placed within.

The main components are right at top level and the directories below
mimic the data structure (unit->page->section).
The toolbar is only used in dev mode and does not belong directly to the
unit view.
The TextEditor is a complex component and deserves it's own directory
even though it is used within the unit-view. Might be refactored to its
own module later.

This is now done via listener directly on the element overlay. The 
overlay's div is made selectable with 'tabindex'. Then the key event is 
caught and delete logic started. The actual logic did not change and 
still deletes all selected elements not just the one catching the delete 
key event.

- This helps getting rid of annoying element interaction and solves some
  selection issues (for example double clicking text elements to bring
  up the editor). While creating units, the placement and properties of
  the elements are important and not interacting with the elements.
  This is what the preview/player is for.
- This may also help with detecting selection for the Delete-key logic.

This now uses "closest" to check parent nodes.
This still does not work properly since some elements can not be clicked 
and the event returns the body element. This might be fixed if a way to 
make those elements clickable is found.

All elements get the 'aspect-inserted-element' class, which is checked 
before deleting the element.

This makes checking the existence of properties for the property panel
possible, since it is possible to check for null but not for undefined.