oelements stores longs which need to be converted to pointers before freeing.
Previously we actually free the entries of the array oelements and not the
stored pointers.

There might be liftime issues with the allocated memory when copying
a pool. Therefore I added a check whether the memory was actually
allocated by the pool when freeing it.

(the problem are operators of the type FieldVector<double,1> *= int)
clang fails and gcc (4.7) warns about
ISO C++ saying that these operators are aambiguous

With g++-4.4 I got the following errors:

fmatrix.hh:106: error: no type named ‘const_iterator’ in ‘class std::initializer_list<std::initializer_list<int> >’

Looking into the header there is indeed the const_iterator (demanded by the standard)
missing. Therefore I refactored the code to use std::copy_n and thus am omitting the iterator
type.

At the same time I made the actual copying safer for the case that the initializer_list
is of different size and people compile with -DNDEBUG. The assertion for the size is still
left in there. Remove the assert or the size computation at your discretion.

We simply return a reference to the internal memory instead of copying the object.
This should save some copying when using FieldVector/FieldMatrix with non-trivial
types.  Also, it fixes crashes I have experienced with the ADOL-C automatic
differentiation toolbox [0].

I hope that this patch doesn't have any nasty side effects.  I didn't see any
so far.  Comments for this patch had been requested in FS 1449, and there have
been no objections.

[0] I have contacted the ADOL-C maintainer about this and he said the crashes
are not really bugs in ADOL-C, but that it is simply very difficult to write
a good operator-overloading AD program that can handle operator K returning
values.

The classes AlwaysFalse, AlwaysTrue reside in the deprecated header
dune/common/static_assert, yet they are frequently used to document
template code (see FS#1435 for details). As the C++11 standard library
does not provide a straight forward replacement for theses classes, we
offer C++11 style reimplementations. The replacements to_false_type,
to_true_type reside in the namespace Std and are thus easily
identifiable as Dune specifis.

Add template parameter for the allocator of the internal std::vector.
All constructors are adadpted to forward a user chosen allocator
to the internal data stroage (std::vector).

Elias pointed out that one of the constructors got lost when merging
with the recent HEAD. This commit adds the missing constructor.

When copying PoolAllocators Bard experienced linking errors to the
copy constructor of Pool, which is deactivated. To fix this we added
the copy constructor. Note that it does not copy the pool such that
ownership of allocated memory chunks is clear.

Kudos go to Bard for noticing this and providing the fix.

In addition we removed the copy constructor of the specialization for
void as the default coy constructor suffices.

Deprecate header and macro dune_static_assert.
Use static_assert instead.

DUNE_FINAL is a helper macro for C++11 and should be placed in
std, where now all compatibility has to be placed.
Beautify Doxygen documentation.

This patch adds an AutoTools test that tests whether the compiler
supports the 'final' keyword.  It defines the DUNE_FINAL preprocessor
macro, which expands to 'final' if the keyword is supported, and
is empty otherwise.

kudos to Elias Pipping, for details see (FS #1166)
as the new Dune requirements are >= g++ 4.4 we are sure that initializer_list is available.

remove output and replace it with assertions.