MakeInvocationExpression helper doesn't belong in SyntheticBoundNodeFactory

[AlekseyTs]

Multiple helpers in SyntheticBoundNodeFactory make use of MakeInvocationExpression helper,
which actually uses a Binder to bind an invocation expression (do overload resolution, apply necessary
conversions to the arguments, etc.). Therefore, there is no guarantee that it is going to produce a node in its lowered form, which we generally expect from SyntheticBoundNodeFactory to do. The helper is used indirectly in lowering and in the post lowering phases of the compiler. When the operation is performed against an unknown set of overloads (and that is how it is used today) the result is unpredictable in terms of what we might get back. For example, we might get back a node that is not going to pass DiagnosticPass checks with respect to operations allowed in an expression tree, resulting in a compiler crash (see, for example, #74163 caused by exactly that). Or we might get back a not lowered node in a post lowering phase, etc.

I propose the following action:

1. Remove the helper in the current form from SyntheticBoundNodeFactory
2. If a binding against an unknown set of overload should occur, that should be done in initial binding phase, the resulting node should be stored "on a side", used by the LocalRewriter and be a subject to DiagnosticPass checks. We have plenty examples of how to do that, just search for use of "placeholders" in bound nodes.
3. Otherwise, we should consider binding against a known and restricted set of overloads with known argument types, so that we can guarantee that we are going to get back a node that doesn't require lowering and cannot contain "forbidden" operations.

        internal BoundExpression MakeInvocationExpression(
            BinderFlags flags,
            SyntaxNode node,
            BoundExpression receiver,
            string methodName,
            ImmutableArray<BoundExpression> args,
            BindingDiagnosticBag diagnostics,
            ImmutableArray<TypeSymbol> typeArgs = default(ImmutableArray<TypeSymbol>),
            bool ignoreNormalFormIfHasValidParamsParameter = false)
        {
            if (_binder is null || _binder.Flags != flags)
            {
                _binder = new SyntheticBinderImpl(this).WithFlags(flags);
            }

            return _binder.MakeInvocationExpression(
                node,
                receiver,
                methodName,
                args,
                diagnostics,
                typeArgs: typeArgs.IsDefault ? default(ImmutableArray<TypeWithAnnotations>) : typeArgs.SelectAsArray(t => TypeWithAnnotations.Create(t)),
                allowFieldsAndProperties: false,
                ignoreNormalFormIfHasValidParamsParameter: ignoreNormalFormIfHasValidParamsParameter);
        }