Add support for non capturing lambda expressions

[adrianoc]

Support lambda expressions that does not capture any context.

Func<int, int, int> supported =  (a,b) => a + b; // Does not capture any context.

int p;
Func<int, int> unsupported = (a) => a + p; // Captures p

One open question is how to handle unsupported scenario:

1. Ignore it and inject a comment in the generated code
2. Throw an exception
3. Other ?

I am leaning to 1

Reasoning

Non-capturing lambdas can be implemented by adding a private, static method with an expression body exactly as the body of the lambda expression.

For instance, the example above would be equivalent to:

Func<int, int, int> Supported() => Supported_Lambda;

private static Func<int, int, int> Supported_Lambda(int a, int b) =>  a + b; 

- [ ] One potential approach to implement this is to do a pass before we start visiting a class and inject synthetic methods for these lambda expressions (this is similar to the lowering concept in Roslyn).
- [ ] For readability it is interesting to add these synthetic methods in the beginning of the type (this ensures that the Cecilified code is more easy to read since there's no mixed instructions)

[adrianoc]

• Ensure capturing lambdas are detected, a warning is emitted and they get ignored
• Ensure conversions from lambda to any delegate type but Func/Action generates a warning (comment?) explaining it is not supported
• Consider adding a comment explaining the generated code most likely will not match 100% the one generated by C# compiler