Add concrete meta-function

concrete(x) returns either x itself by reference or an
uninitialized table of correct type if x is a non-terminal.

concrete is usually used in context where either x or x(...)
are possible inputs for lower level function requiering
contiguous data blocks in memory.

proper type
Clean-up and refurbishing of LU decomposition

Implementation of lu now uses an architecture-dependent version
of trf, which is a direct mapping to the underlying LAPACK kernel.
This allows LU to use MAGMA and other specific version of BLAS/LAPACK.

In addition, proper allocation avoiding scheme is now in place
whenever possible for calls of tie(l,u,...) = lu(a). Previous code
was overcopying in some situations (like non-square input).

This change deprecates the factorization namespace as the internals
of the factorization and the memory handling is done by trf or by
specific version of LU itself. Functions depending on other members
of the defunct lu_result type will be rewrote later using trf.
In Unit Tests, warnings become assertions
Refurbish workspace<T> so it works in current use cases
Emit warning in LU if input is singular
Reimplement det from trf instead of lu_result
Add support for architecture dependant GETRI
Reimplement inv usign trf and tri
Clean-up and update Qr factorisation without pivoting
Implementation of qr now uses an architecture-dependant version of
qrf, which is a direct call to the Lapack kernel.
Both implementations of the kernel with allocation of workspace and
without are in place, the kernel call for allocation of workspace
pass void pointer for matrix A and vector Tau.

Handling exception added but the value returned by xerbla thourgh
mkl is incorrect. Memory handling is done by trf and qr will choose
between qrf and qp3 which will be implemented next.
Exception thrown when a runtime error is triggered from a direct call to a Lapack kernel
Xerbla is the error handler for the Blas,Lapack routines if an input parameter has an invalid
value. By providing our own implementation we can overwrite the default xerbla. This solves
the problem caused by mkl implementation returning random error messages.

Workspace : Every LAPACK routine is able to use a preallocated workspace to optimize its own
memory allocation within the routine itself. This class is a wrapper for these memory buffers
and can be used either as a learning process by passing an empty workspace to a routine and
check how much memory is required or as the regular memory block for internal LAPACK usage.
Lapack functions mainly for QR factorization :
- qp3(d/sgeqp3) : computes a QR factorisation with column pivoting
- gqr(d/sorgqr) : generates the matrix Q (from tau and q) of the factorization efficiently but
does not always computes Q with full ranks
- mqr(d/sormqr) : generates the matrix Q (from tau and q) of the factorization less efficently
but can compute a full rank Q
- swap(d/sswap) : swaps two columns
- laswp(d/slaswp): Performs a series of row interchange on a matrix based on a pivot vector
Update to QR factorization interface :

Changed underlying architecture to make direct calls to lapack kernels making qr_result obsolete.
QR function API is now fully matlab compliant for dense matrix. For this purpose a new system of
policy hierarchies has been setup globally.

Various details functions were added to handle all the cases that occurs in qr implementation.
Benchmarks for lu and qr calls to make sure that the overhead generated by nt2
is not significant compared to direct lapack calls.