[MERGE #4006 @dilijev] OS#14163877: Add caches for Date.prototype.toLocaleString etc, with default params.

Merge pull request #4006 from dilijev:intl-date-toLocaleString-cache

When calling `toLocaleString` functions that are implemented in Intl like `Date.prototype.toLocaleString`, that call is essentially sugar for creating an Intl.DateTimeFormat object, and formatting `this`. We naively throw away that object on the assumption that users will cache an `Intl.DateTimeFormat` object if they plan on making the same format call repeatedly. At a minimum, we can cache the formatter object created when the calls are made with no arguments passed in.

In particular, these two code patterns are semantically identical:

```
let d = new Date();
let formatter = new Intl.DateTimeFormat();
print(formatter.format(d));
```

```
let d = new Date();
print(d.toLocaleString());
```

This change significantly improves the running time when Date.prototype.toLocaleString is called in a loop with default options. #4007 has been opened to track further-reaching improvements related to caching behavior on implicitly-created i18n objects (applicable to both WinGlob and ICU).

The remaining gap in the measurement below between ch and d8 is likely related to debug versus release and WinGlob versus ICU.

```
>eshost -h d8,ch-dev-che3,ch-master-latest caching.js
#### d8
time spent 29 ms
time spent 19 ms
time spent 18 ms

#### ch-dev-che3 # (x64_debug, with this change to add caching behavior)
time spent 106 ms
time spent 43 ms
time spent 45 ms

#### ch-master-latest # (x64_debug, baseline)
time spent 2173 ms
time spent 1676 ms
time spent 1168 ms
```

caching.js

```
const iterations = 1000;
var arr = [];

function testMethod(method) {
    var start = new Date();
    testDateMethod(method);
    var diff = (new Date()) - start;
    print('time spent ' + diff + ' ms');
}

function testDateMethod(method) {
    arr = [];
    var d = new Date();
    for (var i = 0; i < iterations; i++) {
        arr.push(method.call(d));
    }
    return arr.length;
}

function test()
{
    testMethod(Date.prototype.toLocaleString);
    testMethod(Date.prototype.toLocaleDateString);
    testMethod(Date.prototype.toLocaleTimeString);
}

test();
```

No difference in runtime between calling the functions directly versus using `call`.

Additionally:
* Made some refactorings to improve readability of this code and similar code throughout Intl.js
* Fixed #4009: Intl.DateTimeFormat().format.length should be 1
* Fixed #4012: Use an enum instead of magic constants for builtin function IDs

Author: dilijev

lib/Runtime/Library/InJavascript/Intl.js

@@ -1703,41 +1703,53 @@ namespace Js
     */
     Var IntlEngineInterfaceExtensionObject::EntryIntl_RegisterBuiltInFunction(RecyclableObject* function, CallInfo callInfo, ...)
     {
+        // Don't put this in a header or add it to the namespace even in this file. Keep it to the minimum scope needed.
+        enum class IntlBuiltInFunctionID : int32 {
+            Min = 0,
+            DateToLocaleString = Min,
+            DateToLocaleDateString,
+            DateToLocaleTimeString,
+            NumberToLocaleString,
+            StringLocaleCompare,
+            Max
+        };
+
         EngineInterfaceObject_CommonFunctionProlog(function, callInfo);
 
-        //This function will only be used during the construction of the Intl object, hence Asserts are in place.
+        // This function will only be used during the construction of the Intl object, hence Asserts are in place.
         Assert(args.Info.Count >= 3 && JavascriptFunction::Is(args.Values[1]) && TaggedInt::Is(args.Values[2]));
 
         JavascriptFunction *func = JavascriptFunction::FromVar(args.Values[1]);
         int32 id = TaggedInt::ToInt32(args.Values[2]);
+        Assert(id >= (int32)IntlBuiltInFunctionID::Min && id < (int32)IntlBuiltInFunctionID::Max);
 
-        Assert(id >= 0 && id < 5);
         EngineInterfaceObject* nativeEngineInterfaceObj = scriptContext->GetLibrary()->GetEngineInterfaceObject();
         IntlEngineInterfaceExtensionObject* extensionObject = static_cast<IntlEngineInterfaceExtensionObject*>(nativeEngineInterfaceObj->GetEngineExtension(EngineInterfaceExtensionKind_Intl));
 
-        switch (id)
+        IntlBuiltInFunctionID functionID = static_cast<IntlBuiltInFunctionID>(id);
+        switch (functionID)
         {
-        case 0:
+        case IntlBuiltInFunctionID::DateToLocaleString:
             extensionObject->dateToLocaleString = func;
             break;
-        case 1:
+        case IntlBuiltInFunctionID::DateToLocaleDateString:
             extensionObject->dateToLocaleDateString = func;
             break;
-        case 2:
+        case IntlBuiltInFunctionID::DateToLocaleTimeString:
             extensionObject->dateToLocaleTimeString = func;
             break;
-        case 3:
+        case IntlBuiltInFunctionID::NumberToLocaleString:
             extensionObject->numberToLocaleString = func;
             break;
-        case 4:
+        case IntlBuiltInFunctionID::StringLocaleCompare:
             extensionObject->stringLocaleCompare = func;
             break;
         default:
-            Assert(false);//Shouldn't hit here, the previous assert should catch this.
+            AssertMsg(false, "functionID was not one of the allowed values. The previous assert should catch this.");
             break;
         }
 
-        //Don't need to return anything
+        // Don't need to return anything
         return scriptContext->GetLibrary()->GetUndefined();
     }
 

lib/Runtime/Library/InJavascript/Intl.js.bc.32b.h

@@ -519,7 +519,7 @@
               "caller": "Error <large string>",
               "arguments": "Error <large string>"
             },
-            "length": "number 0"
+            "length": "number 1"
           },
           "resolvedOptions": {
             "#__proto__": {