Added foldl, foldr, high order functions for type containers in 'ample'.

This was long overdue, given the attention 'ppmpf' had gotten during early
development over 'ample', but it is here now.

This commit introduces several changes and fixes in clause::ample, the
template meta-programming component of clause. Specifically, the function
abstractions used have been rewritten to make more use of template aliases
as well as clause::ample::ensure. The interface provided through oprt
metahandlers is now to always be considered to be a nested class template
to be used by function abstraction templates (for examples of these, see
<clause/ample/base/fundamentals.hh>).

By far though, all these changes served to provide implementations of
catamorphisms and structure preserving transformations; namely foldl, foldr
and fmap. These guarantee to result into an instantiation of a final type
where the metaprogramming interface provided (as in, set of available oprt
metahandlers as nested class templates) is the one intended to be consumed
by further algorithms. An export mechanism to a specific type abstraction
within 'ample' if more than such interface is needed (to be provided).

A quick example of use for calculations of values, taking advantage of
clause::ample::natural oprt interface semantics:

    #include <clause/ample/vector.hh>
    #include <clause/ample/fmap.hh>
    #include <clause/ample/fold.hh>
    #include <cstdio>

    using namespace clause::ample;

    /* define a sequence of numerical abstractions */
    typedef vector<natural<1>,natural<2>,natural<3>,natural<4>> vec;

    /* find the cube of a numerical abstraction */
    struct cube {
        template<typename X>
	struct oprt_apply {
            typedef mul<X,mul<X,X>> type;
	};
    };

    /* add two numerical abstractions */
    struct adder {
        template<typename X, typename Y>
        struct oprt_apply {
            typedef add<X,Y> type;
        };
    };

    int main() {
        printf("%lu\n", foldl<adder, natural<0>, vec>::value);
        printf("%lu\n", foldr<adder, natural<0>, fmap<cube,vec>>::value);
        return {};
    }

This example is also preliminary to how high order function abstractions are
to be used within clause::ample.
Refactoring ppmpf tuple zip test files.