This will allow for generic template functions that can deal with
complex types using thier underlying value types.  So rather than have:

template<T> T foo(const T&);
template<T> T foo(const std::complex<T>&);

to handle the case where an std::complex<float> should use a float
return value, you can now use a single signature:

template<T> TypeInfo<T>::ValueType foo(const T&);

The type traits will be useful for maping ambiguous C types to fixed
width integer types used for the actual I/O operations, for instance:

  adios::TypeInfo<char>::IOType resolves to int8_t
  adios::TypeInfo<signed char>::IOType resolves to int8_t
  adios::TypeInfo<unsigned signed char>::IOType resolves to uint8_t
  adios::TypeInfo<long int>::IOType resolves to int64_t
  adios::TypeInfo<long long int>::IOType resolves to int64_t

So in this case, even though char and signed char are "the same", they
are distinctly separate types to the compiler.  Using
adios::TyperInfo<T>::IOType you can use the same fundamental type for all
of them.  Similarly for long int and long long int.

This allows us to both drop the namespace prefix when using them in
implementation and guarantee that we don't use versions of the types
that get re-defined elsewhere.

In order to provide the least ammount of disruption this doesn't include
any sweeping search and replace changes.  However, it is recommended
moving forward that these types be used internally when fixed width
sizes are expected.  This will allow the transition to happen gradually
through attrition and minimize conflicts.