Use the backend's copy hook in single-backend to_backend (pytorch#23339)

## What is wrong today

Before ExecuTorch calls a backend's `preprocess`, it copies the program,
so a backend that edits the graph cannot change the caller's program.

`BackendDetails.copy_exported_program_for_preprocess` lets a backend
decide how that copy is made. The default is `copy.deepcopy`. A backend
can override it to share large constant tensors instead of copying them.
The CUDA backend does that in its low-memory mode, because copying model
weights costs as much memory as the weights themselves.

`EdgeProgramManager.to_backend`, which `to_edge_transform_and_lower`
also uses, already calls the hook. But two other paths do not:

- `to_backend(backend_id, edge_program, compile_specs)` calls
`copy.deepcopy` directly.
- `to_backend(edge_program, partitioner)` calls that same function for
every partition.

On those paths a backend's override is ignored, and every constant is
copied. For a large delegate payload that can be gigabytes of extra
memory during lowering.

## What this change does

The single-backend `to_backend` now calls
`cls.copy_exported_program_for_preprocess(edge_program, compile_specs)`
instead of `copy.deepcopy(edge_program)`.

```python
copied_edge_program = cls.copy_exported_program_for_preprocess(
    edge_program, compile_specs
)
```

The default hook is still `copy.deepcopy`, so nothing changes for a
backend that does not override it. Only backends that opted in see a
difference, and they now get the same behavior on every lowering path.

## What was tested

- New unit test in `test_lowered_backend_module.py`: `to_backend` calls
the backend's copy hook once with the program and the compile specs, and
passes what the hook returns to `preprocess`. It fails before this
change (the hook is never called) and passes after it.
- The other tests in that file give the same result before and after.
One end-to-end test fails both ways in my environment, because the
installed runtime does not include the test-only demo backend.

Author: shoumikhin

exir/backend/backend_api.py

@@ -111,7 +111,9 @@ def to_backend(
     # All backend implementation are final, so we don't need to consider nested subclasses.
     for cls in BackendDetails.__subclasses__():
         if backend_id == cls.__name__:
-            copied_edge_program = copy.deepcopy(edge_program)
+            copied_edge_program = cls.copy_exported_program_for_preprocess(
+                edge_program, compile_specs
+            )
             preprocess_result: PreprocessResult = cls.preprocess(
                 copied_edge_program,
                 compile_specs,

exir/backend/test/test_lowered_backend_module.py

@@ -6,6 +6,7 @@
 
 import operator
 import unittest
+from unittest.mock import patch
 
 import executorch.exir.tests.models as models
 
@@ -279,3 +280,23 @@ def test_arrange_graph_outputs_reorders_mutations_before_user_outputs(self):
         self.assertEqual(gi0.args[1], 1)
         self.assertEqual(gi1.args[1], 0)
         self.assertEqual(gi2.args[1], 2)
+
+    def test_to_backend_copies_the_program_through_the_backend_hook(self):
+        # A backend overrides copy_exported_program_for_preprocess to avoid copying
+        # large constants, so to_backend must not deep-copy the program around it.
+        model = models.MLP()
+        edge_program = to_edge(
+            export(model, model.get_random_inputs(), strict=True)
+        ).exported_program()
+
+        with patch.object(
+            DemoBackend,
+            "copy_exported_program_for_preprocess",
+            return_value=edge_program,
+        ) as copy_hook, patch.object(
+            DemoBackend, "preprocess", wraps=DemoBackend.preprocess
+        ) as preprocess:
+            to_backend(DemoBackend.__name__, edge_program, [])
+
+        copy_hook.assert_called_once_with(edge_program, [])
+        self.assertIs(preprocess.call_args.args[0], edge_program)