set find-links per resolve, not globally

As described at
<#21223 (comment)>,
if you set find-links (and that includes everyone with in-repo plugins
by way of `pants.backend.plugin_development`) on one resolve, we were
erroneously setting it for *all* resolves during lockfile generation.
This materially impacts resolution time.

Author: cburroughs

docs/notes/2.31.x.md

@@ -27,6 +27,12 @@ pantsd now preserves web proxy environment variables (`HTTP_PROXY`, `HTTPS_PROXY
 
 ### Goals
 
+#### `generate-lockfiles`
+
+Previously if any Python resolve set `find-links`, then *all* Python resolves used `find-links` during lockfile generation.  Notably this included the `find-links` automatically injected by `pants.backend.plugin_development`.  In Pants 2.31, `find-links` are correctly used per resolve.
+
+Having extraneous un-scoped `find-links` can materially affect dependency resolution time.  In some real world user report >30% improvements in `generate-lockfiles` time.
+
 ### Backends
 
 #### Helm

src/python/pants/backend/python/goals/lockfile.py

@@ -334,13 +334,13 @@ async def setup_user_lockfile_requests(
         return UserGenerateLockfiles()
 
     resolve_to_requirements_fields = defaultdict(set)
-    find_links: set[str] = set()
+    resolve_to_find_links: dict[str, set[str]] = defaultdict(set)
     for tgt in all_targets:
         if not tgt.has_fields((PythonRequirementResolveField, PythonRequirementsField)):
             continue
         resolve = tgt[PythonRequirementResolveField].normalized_value(python_setup)
         resolve_to_requirements_fields[resolve].add(tgt[PythonRequirementsField])
-        find_links.update(tgt[PythonRequirementFindLinksField].value or ())
+        resolve_to_find_links[resolve].update(tgt[PythonRequirementFindLinksField].value or ())
 
     tools = ExportableTool.filter_for_subclasses(union_membership, PythonToolBase)
 
@@ -352,7 +352,7 @@ async def setup_user_lockfile_requests(
                     requirements=PexRequirements.req_strings_from_requirement_fields(
                         resolve_to_requirements_fields[resolve]
                     ),
-                    find_links=FrozenOrderedSet(find_links),
+                    find_links=FrozenOrderedSet(resolve_to_find_links[resolve]),
                     interpreter_constraints=InterpreterConstraints(
                         python_setup.resolves_to_interpreter_constraints.get(
                             resolve, python_setup.interpreter_constraints
@@ -381,7 +381,7 @@ async def setup_user_lockfile_requests(
             out.add(
                 GeneratePythonLockfile(
                     requirements=FrozenOrderedSet(sorted(tool.requirements)),
-                    find_links=FrozenOrderedSet(find_links),
+                    find_links=FrozenOrderedSet(),
                     interpreter_constraints=ic,
                     resolve_name=resolve,
                     lockfile_dest=DEFAULT_TOOL_LOCKFILE,

src/python/pants/backend/python/goals/lockfile_test.py

@@ -341,6 +341,58 @@ def test_multiple_resolves() -> None:
     }
 
 
+def test_find_links_scoped_to_resolve() -> None:
+    rule_runner = PythonRuleRunner(
+        rules=[
+            setup_user_lockfile_requests,
+            *PythonSetup.rules(),
+            QueryRule(UserGenerateLockfiles, [RequestedPythonUserResolveNames]),
+        ],
+        target_types=[PythonRequirementTarget],
+    )
+    rule_runner.write_files(
+        {
+            "BUILD": dedent(
+                """\
+                # Using the underscore field directly instead of pulling all of
+                # pants.backend.plugin_development into the test
+                python_requirement(
+                    name='a',
+                    requirements=['a'],
+                    resolve='a',
+                    _find_links=['https://example.com/wheels'],
+                )
+                python_requirement(
+                    name='b',
+                    requirements=['b'],
+                    resolve='b',
+                )
+                """
+            ),
+        }
+    )
+    rule_runner.set_options(
+        [
+            "--python-resolves={'a': 'a.lock', 'b': 'b.lock'}",
+            "--python-enable-resolves",
+        ],
+        env_inherit=PYTHON_BOOTSTRAP_ENV,
+    )
+    result = rule_runner.request(
+        UserGenerateLockfiles, [RequestedPythonUserResolveNames(["a", "b"])]
+    )
+    assert all(isinstance(r, GeneratePythonLockfile) for r in result)
+    result_by_resolve = {r.resolve_name: r for r in result}
+    assert isinstance(result_by_resolve["a"], GeneratePythonLockfile)
+    assert isinstance(result_by_resolve["b"], GeneratePythonLockfile)
+
+    assert result_by_resolve["a"].requirements == FrozenOrderedSet(["a"])
+    assert result_by_resolve["b"].requirements == FrozenOrderedSet(["b"])
+
+    assert result_by_resolve["a"].find_links == FrozenOrderedSet(["https://example.com/wheels"])
+    assert result_by_resolve["b"].find_links == FrozenOrderedSet([])
+
+
 def test_empty_requirements(rule_runner: PythonRuleRunner) -> None:
     with pytest.raises(ExecutionError) as excinfo:
         json.loads(