In contain hand-coded architecture-specific settings for a lot
of different architectures.  We throw them all out.  The AutoTools
are the only way to build UG from now on.

These architectures are not used anymore, and the clocks are not used
anywhere in the ug code.

In particular, replace compiler.h by ugtypes, architecture.h,
and ugtime.h. The stuff in compiler.h will from now on be handled
by config.h and friends exclusively.

The CEIL macro uses alignment information, which should not appear
in installed headers.

This fixes a series of memory leaks reported by valgrind for the
Dune UGGrid test.

This method only frees the HEAP memory if the internal heap is used.
When using the system heap, however, the HEAP data structure contains
a C-array of std::vectors, created by placement new.  Hence, before
freeing the memory, those vectors need to have their destructors
called.  Otherwise, their memory will leak.

Because nobody uses that compiler for Apple anymore.  Apparently they never
even did a version for Apples with Intel processor.

When UG creates a new element, and SideVectors are switched on,
then a new SideVector is created for each face of the new element.
Since most faces are shared by two elements, though, the consequence
is that there are two SideVectors for each interior face.  To obtain
a single SideVector per face (as it should be), the UG refinement
code calls the method DisposeDoubledSideVector for these duplicated
SideVectors.  This appears to be easier than only creating one
SideVector for each face to begin with.

However, so far the duplicate SideVectors were not disposed in a
green, non-rule based refinement of an element.  This lead to
memory leaks which could be observed when running the Dune UGGrid
test with --enable-system-heap and valgrind.  This patch adds
the missing calls to DisposeDoubledSideVector, and fixes those
leaks.

Incidentally, this also appears to be the proper fix for the issue
described in Dune FlySpray 170,

https://dune-project.org/flyspray/index.php?do=details&task_id=170

which had previously been hacked around in dune-grid.

In my eyes, this makes code easier to read.

This becomes bool when compiled as C++, and _Bool when compiled as C.

It makes the code and the debugger output easier to read.

This fixes a memory leak, as could be observed in valgrind.

I had simply misspelled it in the DisposeMem method.
It's a surprise the program never crashed with such a severe
bug in it.

No further changes necessary.  The argument really is const and never
modified.

The virtual communication channels allocated for the tree structure were
never freed.  Additionally, the ppif layer may get initialized twice:
when called from Dune, its gets initialized both for the 2d UGGrid and
for the 3d UGGrid.  In that case, the channels initiated for 2d leaked
when being overwritten by newly allocated channels for 3d.

Which is not empty, but contains the text "Leave this file here!".
The file was placed there in 1995, never touched, and is not apparently
referenced from anywhere else.  So out it goes...

This silences a few warnings I get from recent AutoTools