Assuming 32b integers and coordinates

Among various fixes and corrections, a major design decision was made
with respect to the current coordinates and as well to IOD's final
coordinate system. The following axiomatic requirement reflects this:

For all coordinates which need to evaluate with known precision, we
require that they may be scaled with any decimal number to a precision
no less than the desired precision of the resulting coordinate,
efficiently. All assuming, that the result does not overflow the target
coordinate system.

Hence (from efficiency), we require that we may apply ordinary floating
point operations (i.e. multiplication with the "*" operator, etc.) to
these coordinates. Since these ordinary floating point operations work,
by definition, on two floating points, the coordinate must be casted to
floating point with adequate precision.

Since the largest (readily available) floating point number - the double
- has precision up only to the 54th bit, we must choose, for every
coordinate, an integer type with less than 54bits. Therefore, all
coordinates are henceforth integers (or unsigned integers).

Another distinct decision was made which is closely related: We want to
be able to represent distances and apply the same requirement regarding
precise scaling to distances, too. In a non-euclidian, orthogonal
coordinate system, we must select one of the three coordinate axes as a
reference for scale. That is to say that 1 unit of distance corresponds
to n units along that axes. In other words, we fix the scale of the
metric.

In any case, we assume the metric is scaled such that the largest
difference vector in the coordinate system (reaching from one corner to
the opposing corner) is represented by the maximally representable
distance. Because of the first requirement, the distance is also
represented as 32 integer (naturally unsigned).

The normalization requirement is then

sqrt( g00 + g11 + g22 ) = MAXDIST/( 2*|MAXCOORD| )

This is current NOT in the code. The implementation is not point of this
exercise and will mean a lot of useless overhead (notion of a metric for
position vectors, etc). For now the coordinates are simply limited to
1/sqrt(3) times the maximal uint32 value (the maximum distance) and the
metric assumed unity.

Code now compiles.