avm2: Speed up some native calls

[Lord-McSweeney]

This allows us to optimize some calls to native functions when

1. the function has a [Ruffle(FastCall)] annotation,
2. the arguments are of the correct count and type, and
3. the class of the value the function is being called on is final.

For example, Math.abs runs more than twice as fast with this PR as it does on current master. From my testing, in most SWFs, 5-20% of calls that would be CallMethod are now CallNative.

Box2d stats:

ConstructSuper -> Pop: 70%

FindPropStrict -> GetScriptGlobals: 82.67%
FindPropStrict -> GetOuterScope: 8.96%
FindPropStrict -> GetScopeObject: 8.36%

FindProperty -> GetOuterScope: 5.66%
FindProperty -> GetScopeObject: 94.33%

InitProperty -> SetSlot: 6.28%
InitProperty -> SetSlotNoCoerce: 90.98%
InitProperty -> CallMethod: 2.73%

SetProperty -> SetSlot: 8.07%
SetProperty -> SetSlotNoCoerce: 73.88%
SetProperty -> CallMethod: 2.4%

GetProperty -> GetSlot: 88.92%
GetProperty -> CallMethod: 0.47%

CallProperty -> CallMethod: 74.1% (-9.16%)
CallProperty -> CallNative: 9.16% (+9.16%)
CallProperty -> CoerceUSwapPop: 5.17%
CallProperty -> CoerceISwapPop: 9.56%

CallPropVoid -> CallMethod: 91.72% (-2.25%)
CallPropVoid -> CallNative: 2.25% (+2.25%)

ConstructProp -> ConstructSlot: 100%

Coerce -> Nop: 73.18%

CoerceD -> Nop: 98.75%

CoerceB -> Nop: 97.29%

CoerceU -> Nop: 64.91%

CoerceI -> Nop: 52%

ReturnValue -> ReturnValueNoCoerce: 96.39%

TODO:

• Record box2d optimization stats
• Add documentation on FastCall to the globals README
• Use a HashSet for the FastCall methods...?

[moulins]

Use a HashSet for the FastCall methods...?

An alternative (maybe simpler to implement?) could be to sort the static array, and use binary_search for O(log n) lookups.

[adrian17]

If you sorted the vec before putting it in, we could use binary_search instead of iter().any() to speed up* lookups without affecting memory use at all.
Alternatively, there's always https://github.com/rust-phf/rust-phf to construct a static hashset at compile time (and thus not waste any allocations), but might be an overkill here.

(*I imagine the difference might not matter as long as we have <100 fast methods. )