Add an ITypedValueExpressionFactory<T> interface for our typed value expressions

[ArcturusZhang]

Fixes #3312

Majority of our typed value expressions will have the ctor taking a ValueExpression parameter, like this:

public record XExpression(ValueExpression Untyped) : TypedValueExpression(typeof(X), Untyped)

and we cannot add a constraint using generic syntax, this cannot compile:

public static MethodBodyStatement Declare<T>(string name, T value, out T variable) where T : TypedValueExpression, new(ValueExpression)

to have a generic method to catch all of the cases we could possibly support, we could use this newly introduced interface as the constraint:

public static MethodBodyStatement Declare<T>(string name, T value, out T variable) where T : TypedValueExpression, ITypedValueExpressionFactory<T>

where ITypedValueExpressionFactory<T> works similarly as the made-up constraint above new(ValueExpression).

I believe this should simplify our code, and make it could automatically extend when a new expression is added.

[ArcturusZhang]

@m-nash @ShivangiReja @jorgerangel-msft could you please have a review? This is ready to review now.

[azure-sdk]

API change check

APIView has identified API level changes in this PR and created following API reviews.

Microsoft.Generator.CSharp

[m-nash]

Is there any reason we don't add explicit cast operators here instead?

Also should this fail if the ValueExpression given is not a BinaryDataExpression? How would we check that?

[ArcturusZhang]

this is supposed to wrap a untyped expression to this specific typed expression, works as the same as its ctor.
I use this to work as a constraint of "it has a ctor with parameter of valueexpression"

Also should this fail if the ValueExpression given is not a BinaryDataExpression? How would we check that?

No, our typed expressions do not work in this way.

[m-nash]

If this is the case "it has a ctor with parameter of valueexpression", why not just let the user call new BoolExpression(valueExpression) vs BoolExpression.Create(valueExpression). in dotnet land the new ctor syntax is much more discoverable?

[ArcturusZhang]

the whole point is not for how our use would construct this, despite this may have affects on that part.
This is trying to introduce a "generic constraint" so that we could have:

MethodBodyStatement Declare<T>(string name, T expression, out T variable)

as I have written in the description.
Adding this does not remove the ctor though. And I kind of do not want users (plugin writers) to call this method therefore I always explicitly implement those methods.