Update methods from initial binding based on inferred nullability

[cston]

There are a number of cases in NullableWalker where methods from initial binding should be updated based on the inferred nullability.

For instance, both calls to .ToString() below should report warnings but no warning is reported for the second case currently.

#nullable enable
class C<T>
{
    internal T F() => throw null;
}
class Program
{
    static C<T> Create<T>(T t)
    {
        return new C<T>();
    }
    static void F(string? s)
    {
        new C<string?>().F().ToString(); // warning: maybe null
        Create(s).F().ToString();        // no warning
    }
}

Test cases affected: NullableReferenceTypesTests.ImplicitConversions_07

[jcouv update:] both calls to .ToString() now report warnings (sharplab) but more references to this issue remain in the source.

[jcouv]

Note that I've replace one or more PROTOTYPE markers with references to this issue since they should be considered when fixing this issue:

        public override BoundNode VisitCall(BoundCall node)
        {
            // Note: we analyze even omitted calls
            var method = node.Method;
            var receiverOpt = node.ReceiverOpt;
            if (receiverOpt != null && method.MethodKind != MethodKind.Constructor)
            {
                VisitRvalue(receiverOpt);
                CheckPossibleNullReceiver(receiverOpt);
                // Update method based on inferred receiver type: see https://github.com/dotnet/roslyn/issues/29605.
            }

            // https://github.com/dotnet/roslyn/issues/29605 Can we handle some error cases?
            // (Compare with CSharpOperationFactory.CreateBoundCallOperation.)
            if (!node.HasErrors)
            {
                ImmutableArray<RefKind> refKindsOpt = node.ArgumentRefKindsOpt;
                (ImmutableArray<BoundExpression> arguments, ImmutableArray<Conversion> conversions) = RemoveArgumentConversions(node.Arguments, refKindsOpt);
                ImmutableArray<int> argsToParamsOpt = node.ArgsToParamsOpt;

                method = VisitArguments(node, arguments, refKindsOpt, method.Parameters, argsToParamsOpt, node.Expanded, node.InvokedAsExtensionMethod, conversions, method);
            }

            UpdateStateForCall(node);

            if (method.MethodKind == MethodKind.LocalFunction)
            {
                var localFunc = (LocalFunctionSymbol)method.OriginalDefinition;
                ReplayReadsAndWrites(localFunc, node.Syntax, writes: true);
            }

            //if (this.State.Reachable) // Consider reachability: see https://github.com/dotnet/roslyn/issues/28798
            {
                _resultType = method.ReturnType;
            }

            return null;
        }