Refactor weights, biases and other embedded tensors to use a Constant Layer

[Gaudeval]

Constants result in tensors hidden or nested inside the layer definition, with special cases to capture them during code generation. Instead we could introduce a Constant layer producing a single output tensor. The Constant Layer could be plugged as the producer for all those weights, biases, and others.

This should remove special cases such as MatMul depending on an enum to know if it has one or two inputs, and if the single input is the left or right operand.

During ONNX imports, all initializers should produce a Constant Layer.

[Gaudeval]

Constant layers are in, and the MatMul special cases are gone. However more layers need to go through the same diet.

[elfman2]

Unfortunately it adds overhead in the generated code to copy constant values into the output var

int inference(short prediction[5], short nn_input[5]){
    int f;
    int i;
    int j;
    int k;

    int dotproduct;


    // Input_layer_00 (layer X in  input model)
    // Loading the input in channels_first
    for (k = 0; k < 5; ++k)
    {
        output_0[k] = nn_input[k];
    }


    // Constant_12 (layer B5 in  input model)
    // Load the constant
    for (k = 0; k < 5; ++k)
    {
    output_1[k] = weights_Constant_12[k];
    }


    // Constant_11 (layer W5 in  input model)
    // Load the constant
    for (k = 0; k < 80; ++k)
    {
    output_2[k] = weights_Constant_11[k];
    }


    // Constant_10 (layer B4 in  input model)
    // Load the constant
    for (k = 0; k < 16; ++k)
    {
    output_3[k] = weights_Constant_10[k];
    }


    // Constant_09 (layer W4 in  input model)
    // Load the constant
    for (k = 0; k < 512; ++k)
    {
    output_4[k] = weights_Constant_09[k];
    }


    // Constant_08 (layer B3 in  input model)
    // Load the constant
    for (k = 0; k < 32; ++k)
    {
    output_5[k] = weights_Constant_08[k];
    }