Interop: a collection exposed as IList<T> or IReadOnlyList<T> gets the wrapper that contract names

[lahma]

Fixes #3421.

ResolveArrayLikeWrapperFactoryType decides which wrapper an exposed type gets by scanning
t.GetInterfaces() for IList<> and IReadOnlyList<>. An interface is not among its own
GetInterfaces(), so when t is one of those two the scan finds nothing:

typeof(IList<int>).GetInterfaces()          // ICollection<int>, IEnumerable<int>, IEnumerable
typeof(IReadOnlyList<int>).GetInterfaces()  // IReadOnlyCollection<int>, IEnumerable<int>, IEnumerable

Exposing a collection as one of the two contracts the method is written to recognize therefore found
nothing, and the engine fell back to a wrapper the exposure had not named. That exposure is public API
(ObjectWrapper.Create(engine, target, type)), it is what a WrapObjectDelegate supplies, and it is what the
member lane passes for a property whose declared type is a collection interface — so it is reachable under
a plain JIT, with no trimming and no Native AOT anywhere near it.

exposure	main	this PR
a host IList<T> (not a non-generic IList) as IList<T>	plain ObjectWrapper	GenericListWrapper<T>
a List<T> as IList<T>	untyped ListWrapper (element type object)	GenericListWrapper<T>
a List<T> or T[] as IReadOnlyList<T>	ListWrapper, writability read from the target	ReadOnlyListWrapper<T>
a host IReadOnlyList<T> (not an IList) as IReadOnlyList<T>	plain ObjectWrapper	ReadOnlyListWrapper<T>
as ICollection<T> / IEnumerable<T>	plain ObjectWrapper	unchanged — those contracts name no view

What the first row means for an embedder:

// engine.SetValue("host", ObjectWrapper.Create(engine, items, typeof(IList<int>)))
Object.keys(host)                     // main: ["IndexOf","Insert","RemoveAt"]   here: ["0","1","2"]
host[3] = 9                           // main: ArgumentOutOfRangeException        here: grows to 1,2,3,9
Array.prototype.push.call(host, 4)    // main: TypeError (§4.37)                  here: 4
Array.prototype.pop.call(host)        // main: TypeError                          here: removes the last

Reads are unchanged in every row — host.length, host[1], the generics, Array.from, spread and
JSON.stringify all answered correctly through the plain wrapper's reflection lane already, and
ReadsThroughAnExposedContractAreUnchanged is the ten rows that say so.

One guard comes with it. Every typed factory casts the target to the contract the exposure named, and
until the exposed type itself was consulted a factory could only be found by scanning the target's own
interfaces — so the cast could not fail. TryBuildArrayLikeWrapper now requires type.IsInstanceOfType(target)
before using the factory, so a host handing Create a type its target does not implement keeps the answer it
has always had rather than getting an InvalidCastException out of a wrapper creation.

Proof

Jint.Tests.PublicInterface/HostExposedCollectionTypeTests.cs — the file #3425 added for this exposure — is
rewritten around the contract rather than around the wrapper it accidentally got. Against unmodified main,
9 of its 33 cases fail:

Failed TheExposedContractDecidesTheWrapper("IndexedItems","IList<int>","GenericListWrapper`1")
Failed TheExposedContractDecidesTheWrapper("List<int>","IList<int>","GenericListWrapper`1")
Failed TheExposedContractDecidesTheWrapper("int[]","IList<int>","GenericListWrapper`1")
Failed TheExposedContractDecidesTheWrapper("ReadOnlyItems","IReadOnlyList<int>","ReadOnlyListWrapper`1")
Failed TheExposedContractDecidesTheWrapper("List<int>","IReadOnlyList<int>","ReadOnlyListWrapper`1")
Failed TheExposedContractDecidesTheWrapper("int[]","IReadOnlyList<int>","ReadOnlyListWrapper`1")

Failed AnExposedCollectionEnumeratesItsPositions
   Expected string to be the same string, but they differ at index 1
   (["IndexOf","Insert","RemoveAt"] for a target script sees as a list)

Failed AWritableExposedContractIsWritableAndGrowable
   Jint.Runtime.JavaScriptException : Cannot assign to read only property '3' of object '#<Object>'

Failed NoOperationOnAnExposedCollectionLetsAClrExceptionPastScript("IndexedItems","IList<int>")
   ... but found System.ArgumentOutOfRangeException: Index was out of range.

Failed!  - Failed: 9, Passed: 24, Skipped: 0, Total: 33

The contrast cases pass on main and still pass: the exposures under ICollection<T> / IEnumerable<T> that
must stay plain, the ten read rows, and the exposed type the target does not implement.

What this narrows

ArrayOperations.IndexWrappedOperations is once again reachable only under Native AOT. The plain-JIT route
#3394 found — and that
§4.37 documents — was this defect,
not a shape of the engine: the exposure that reached the lane now gets a typed wrapper. The refusal #3425
added to that lane is still what a runtime with no code for the typed factory's value-type instantiation
gives, and Jint.AotExample's IList<int> probe is again the only coverage it has — the comments in
ArrayOperations.cs and Jint.AotExample/Program.cs say so, and the latter says not to delete the probe for
want of a sibling test.

docs/v5-migration.md §4.57 carries the embedder-facing form and narrows §4.37.

Merge last of the three (#3464, #3472, then this): all three touch Jint/Runtime/Interop/ObjectWrapper*.cs
and docs/v5-migration.md, and this one is the behaviour change the other two should be in place for.