Improve Printable and Convertible concept.

The old Printable concept relied on two functions, print() and render(),
which had to work in a complicated way in conjunction. This commit replaces the
old API with a newer, simpler API. Any type that models the Printable concept
only needs to provide one free function:

    template <typename Iterator>
    trial<void> print(T const& x, Iterator&& out);

When providing this function, the framework will inject new functions:

    - basic_ostream<C, T>& operator<<(basic_ostream<C, T>& out, T const&);

    - template <typename From>
      std::string convert(From const& from, std::string& str);

Moreover, one can now rely on a new conversion function:

    template <typename To, typename From>
    trial<To> to(From const& from);

For that function to get activated, on needs to provide the following
conversion function:

    - template <typename To, typename From>
      trial<void> convert(From const& from, To& str);

For any Printable type, the framework also generates a conversion function to
std::string automatically.

This commit also cleans up other APIs:

    - The class util::error now has a variadic contructor, which attempts to
      print each argument in the contained string. That is, each argument must
      fulfil the Printable concept.

    - The function util::trial<T>::failure() got renamed to
      util::trial<T>::error().

    - The trial<nothing> idiom went away. The new idiom is trial<void> and one
      returns 'nothing' instead of 'nil' to indicate success.

    - The exist several convenience headers which hoist functionality from the
      util namespace into namespace vast, e.g., vast/trial.h or vast/error.h.
Remove experiments.
Finish new Printable and Parseable concepts.

We have now a new printing and parsing framework. It is symmetric (The print
and parse API are a dual of each other), non-intrusive via ADL.

It is also unified as it inejcts a conversion function to<T>(..) when possible.
For example, all types T modelling Printable automatically get to_string(T) and
to<std::string>(T), where the former returns a plain string and the ladder a
trial<std::string>. Further, all types modelling the Parseable concept get a
function to<T>(std::string const&), to<T>(char const (&buf)[N]) and so forth.
This gives the function to<T>(...) a lot of power.

Further changes:

    - Move all Boost Spirit grammar definitions into the header files. While it
      increases compile times, it is necessary to do so because we cannot
      anticipate the iterator type of the parse function in advance.

    - Ignore a few warnings from Boost Spirit (Clang only).

    - Begin removal of string constructors for parseable types. Since we're not
      always able to check the input data, it is safer to go via parse() and
      then check the trial.
Merge branch 'print-parse'

* print-parse:
  Finish new Printable and Parseable concepts.
  Remove experiments.
  Improve Printable and Convertible concept.