gh-157230: test_importlib restore builtins

Our CI (https://github.com/facebookincubator/cinder/actions/runs/29382592631/job/87249270535)
was failing on test_pickle and test_pickletool with:

```
PicklingError: Can't pickle
<class 'importlib._bootstrap.BuiltinImporter'>:
it's not the same object as
importlib._bootstrap.BuiltinImporter
```

I believe this is happening because we run multiple test
modules in the same interpreter, so the following sequence
happens:

* `test_importlib.util.import_importlib()` imports a source copy of
  `importlib` while blocking `_frozen_importlib`. During this import,
  `importlib._bootstrap._setup()` initializes import metadata on existing
  built-in modules. If `builtins.__loader__` or `builtins.__spec__` was
  originally absent, the source copy installs its own `BuiltinImporter`.
* Although `import_fresh_module()` restores `sys.modules`, it does not restore
  attributes mutated on existing module objects. Consequently,
  `builtins.__loader__` continues to reference the temporary source
  `BuiltinImporter`, while `importlib._bootstrap.BuiltinImporter` resolves to
  the restored frozen class.
* Pickle serializes classes by module and qualified name and verifies that the
  resolved global is the same object. The two `BuiltinImporter` class objects
  therefore cause the identity check to fail.

To fix this we instead snapshot `__loader__` and `__spec__` before importing
`importlib` and then restore them to their original values after.

Author: kddnewton

Lib/test/test_importlib/test_util.py

@@ -33,6 +33,22 @@
     _interpreters = None
 
 
+class ImportImportlibTests(unittest.TestCase):
+
+    def test_restores_missing_import_metadata(self):
+        # importlib._bootstrap._setup() installs the loader classes of the
+        # source copy on any module that has no __spec__ of its own.
+        for name in ('builtins', 'sys'):
+            module = sys.modules[name]
+            with self.subTest(module=name):
+                with (support.swap_attr(module, '__spec__', None),
+                      support.swap_attr(module, '__loader__', None)):
+                    util.import_importlib('importlib')
+
+                    self.assertIsNone(module.__spec__)
+                    self.assertIsNone(module.__loader__)
+
+
 class DecodeSourceBytesTests:
 
     source = "string ='ü'"

Lib/test/test_importlib/util.py

@@ -64,12 +64,48 @@ def _extension_details():
 _extension_details()
 
 
+_MISSING = object()
+
+
+@contextlib.contextmanager
+def _restore_import_metadata():
+    """Keep the source copy of importlib out of other modules' metadata.
+
+    Importing importlib with _frozen_importlib blocked runs
+    importlib._bootstrap._setup(), which fills in __spec__ and __loader__ on
+    every builtin and frozen module that lacks them. After the import, this
+    context restores the original values of those attributes on all modules that
+    were modified so those modifications don't leak into other tests.
+    """
+    incomplete = {}
+    for name, module in list(sys.modules.items()):
+        if isinstance(module, types.ModuleType):
+            for attr in ('__spec__', '__loader__'):
+                value = getattr(module, attr, _MISSING)
+                if value is None or value is _MISSING:
+                    incomplete[name, attr] = value
+    try:
+        yield
+    finally:
+        for (name, attr), value in incomplete.items():
+            module = sys.modules.get(name)
+            if module is not None and getattr(module, attr, _MISSING) is not value:
+                if value is _MISSING:
+                    delattr(module, attr)
+                else:
+                    setattr(module, attr, value)
+
+
 def import_importlib(module_name):
     """Import a module from importlib both w/ and w/o _frozen_importlib."""
     fresh = ('importlib',) if '.' in module_name else ()
     frozen = import_helper.import_fresh_module(module_name)
-    source = import_helper.import_fresh_module(module_name, fresh=fresh,
-                                         blocked=('_frozen_importlib', '_frozen_importlib_external'))
+    with _restore_import_metadata():
+        source = import_helper.import_fresh_module(
+            module_name,
+            fresh=fresh,
+            blocked=('_frozen_importlib', '_frozen_importlib_external'),
+        )
     return {'Frozen': frozen, 'Source': source}