Many library improvements

Algorithms:
===========

 - High-order metafunctions from "algorithm.hpp" moved to a new header "high_order_functions.hpp".
   This reduces coupling allowing other headers to use the high-order metafunctions, without coupling
   with the other algorithms. So now more algorithms could be implemented using features relying
   on high-oreder functions (Later situations like these result in include cicles).

 - tml::repeat algorithm: Given a type, returns a list filled with that type the specified number of
   times.

Algebra and math:
=================

 - Algebraic primitives tml::zero, tml::one to represent the primitives 0 and 1 on different numeric
   representations.

 - Metafunctions to retrieve the sign of a numeric value, its opposite value, and its absolute value.

 - A math library (math.hpp), with math algorithms. tml::pow metafunction.

Fixed-point:
============

 - Finished the implementation of the tml::fixed_point type: Implemented tml::to_runtime() specialization,
   the complete set of algebraic operations and primitives, and casting metafunctions between integral
   and fixed-point values.

 - tml::decimal (And friends) metafunctions to instantiate fixed-point values using decimal scientific
   notation.

Lazy:
=====

 - Implemented tml::lconditional (lazy-conditional) control structore for conditional selection of
   potentially ill-formed types.

 - The behaviour of tml::lazy_instance has changed to help on some contexts: When the parameter is not
   a tml::lazy template instance, tml::lazy_instance acts as an identity function, returning the parameter
   unchanged.

Type traits:
============

 - tml::is_fixed_point trait.

Zoo (Placeholders and chamaleons):
==================================

 - tml::runtime::chameleon, a constexpr class to give a working value for any (Runtime or compile-time) context.
 - tml::runtime::placeholders, compile-time/runtime value placeholders.

 - tml::non_evaluated_function_chameleon: The Turbo expression evaluation mechanism is based on the processing of
   any valid expression (Simple, parametrized, or functional) transforming the input expression to compute its value.
   Thus the evaluation should be completely separated from the instantation of the original expression. This is why
   some workarounds (Like chameleons) are needed: A non-evaluated part of an expression should be a valid parameter for
   the enclosing expression, until the expression evaluation (After the parameter is evaluated and will be valid).
   This scheme works well with total metafunctions (Metafunctions with a defined result for any input), but not for partial
   metafunctions, like the algebraic operations. Consider this:

       using result = tml::eval<tml::add<tml::div<tml::Int<10>,
                                                  tml::Int<2>
                                                 >,
                                         tml::Int<1>
                                        >
                               >;

   The algebraic metafunctions tml::add and tml::div are defined (Specialized) for numeric values only, so this expression
   doesn't even compile (There is no tml::add specialization to add a tml::div instance and a tml::Int). Even if the expression
   seems to be well-formed (Is (10/2) + 1), is not because the semantic of the expression is not (10/2)+1 until the evaluation. Before
   is just a template which should be instanced. And there is no specialization.

   The good solution was to decouple completely the correctness (Is well-formed or not) of an expression from its instantation. Note that Turbo expressions
   are processed in two phases (First the expression is instantiated, and that instantation should be correct. Later the instanced
   expression is evaluated).
   To solve the problem all Turbo metafunctions are declared as total functions (Even if they are not). The default template of a
   partial metafunction could inherit from the tml::non_evaluated_function_chameleon type to behave like a total function and make
   the instantation (1st phase of expression processing) possible.

Minor changes:
==============

 - #include's refactored to point to "high_order_functions.hpp", only including "algorithm.hpp" if neccesary.
 - Some documentation fixes.
Merge branch 'reboot' of https://github.com/Manu343726/Turbo into reboot