They are outdated and need substantial updates

Key differences:
 - LigandScorer does not automatically extract non-polymer ligands
   anymore, ligand extraction must happen externally
 - LigandScorer performs cleanup of receptor structure 1) removal of
   hydrogens 2) removal of residues for which there is no entry in
   the PDB component dictionary 3) removal of residues that are not
   peptide linking or nucleotide linking according to PDB component
   dictionary 4) removal of atoms that are not defined for the
   respective entry in the PDB component dictionary.
 - Cleanup is Logged and available as output
 - compare-ligand-structures action does not support automatic
   extraction of ligands from PDB structures anymore. This feature
   still works if structures are provided as mmCIF.
 - compare-ligand-structures action adds receptor structure cleanup
   logs and input parameter in json output to improve
   reproducibility of results.

This changes the CSV output file to list one model ligand per line,
instead of one reference ligand.

The breadcrumbs now correctly indicate the module hierarchy and can be
used to determine imports. All the documentation for ost.* is now rooted
on the base `ost` module for more clarity.

Parasail: https://github.com/jeffdaily/parasail

It's faster than the pairwise sequence algorithms we have in
OpenStructure. However, the main reason to check out another solution
is the fact that OpenStructure may return suboptimal alignment
results. This is a result of how the dynamic programming table is built.
If for a certain cell in the dynamic programming table a match state and
insertion state score equally, match is preferred. There is a chance
that we would get a better score later on if we would stick with the
insertion state (gap open penalties vs. gap extension penalties).
Not sure if this will be fixed in the near future.

Numpy support in C++ enabled features at two points:
Efficient way of setting positions in entity handles or setting meshes
in gfx.PrimList.

Support for newer numpy versions would've required an effort to implement.
As far as I know, no one uses these features (fingers crossed) so let's just
dump numpy alltogether to simplify the build system.

Document default values for minimum peptide/nucleotide lengths

Minimum length for a chain in the target structure
to be considered in chain mapping. The chain mapping algorithm first
performs an all vs. all pairwise sequence alignment to identify
"equal" chains within the target structure. We go for simple sequence
identity there. Short sequences can be problematic as they may
produce high sequence identity alignments by pure chance.

BUT: if you're scoring peptides or short nucleotides, you
really want to be able to reduce the default thresholds
(pep: 10, nuc: 4)

This updates the module versions to match the versions we currently use
for the OST module on sciCORE.

There are two use cases for this parameter: 1) decide whether a chain
mapping problem is actually solvable by naive enumeration and crash out if not
2) As a decision whether one should use naive enumeration or a heuristic
approach for chain mapping.

For the latter, n_max_naive meant the number of chains in the underlying
structure. Now its number of possible mappings for both cases.

requested by Andriy. Computes all IPS metrics on a per-interface basis

requested by Andriy. Computes all ICS metrics on a per-interface basis

enable contact scores and separate dockq and per-interface qs scores

Mainly for reporting in the compare-structures action
residues are reported as strings in format:
<cname>.<rnum>.<ins_code>, atoms are reported as
<cname>.<rnum>.<ins_code>.<aname>. This changes behaviour of
compare-structures and ost.mol.alg.stereochemistry
(ToJSON functions of violation info objects for the latter).

This sets up the compound lib upon calling import ost.
It simplifies the ost_startup.py script accordingly.
It is now possible to override the compound lib with
an environment variable: OST_COMPOUNDS_CHEMLIB

- Tell the user that biounit indices are 0-based
- More info in output on what chains are actually processed