refactor(toolkit-lib): compute each resource's property hash once per refactor

[Adityaj0]

Fixes #1824

Reason for this change

A RefactoringContext computes digests four times for one environment: resourceMoves handles the deployed and the local stacks in the 'direct' direction, then structuralOverrides repeats both in the 'opposite' direction.

Only the dependency half of a digest depends on the direction. The other input — hashObject(stripReferences(stripConstructPath(resource), exports)), which is where nearly all the CPU goes because it walks and hashes the resource's whole property tree — is a pure function of the resource and the stacks' exports, and is byte-identical in every pass. It is recomputed from scratch in each of them.

Description of changes

Added an optional PropertyHashCache (a Map keyed by the resource object) to computeResourceDigests, consulted before hashing and populated after. RefactoringContext creates one in its constructor and threads it through resourceMoves, structuralOverrides and resourceDigests, so all four passes share it.

Two deliberate choices:

• The cache is scoped to one operation, not module state. Keys are the resource objects themselves, so a longer-lived cache could outlive the templates it was built from and go stale if a caller mutated one. Owning it in the constructor bounds its lifetime to the refactor.
• The parameter defaults to a fresh Map. Every existing caller of computeResourceDigests — including the tests — behaves exactly as before without changes.

Digests are unchanged; only how often they are computed changes.

Description of how you validated changes

• New regression test asserting that digests computed with a cache shared across both graph directions are identical to digests computed without one, for both directions.

• All 55 tests under test/api/refactoring/ pass.

• Benchmark — synthetic CDK-shaped templates (nested policy documents, tags, Ref/Fn::GetAtt cross-references, DependsOn, aws:cdk:path on every resource), timing exactly the four computeResourceDigests calls a RefactoringContext performs. Cold node process per measurement, min of 7 runs:

  template shape	JSON size per side	before	after	improvement
  1 stack × 200 resources	0.6 MiB	48.6 ms	32.6 ms	32.9%
  5 stacks × 200 resources	3.0 MiB	238.2 ms	156.4 ms	34.4%
  10 stacks × 400 resources	22.2 MiB	1542.1 ms	961.6 ms	37.6%

  Each measurement is a single cold execution, so the cache starts empty exactly as in a real CLI invocation: two passes fill it, two read from it. Timing repeated iterations inside one process would report ~80%, but only because the cache is already warm by then — that number would not reflect what a user sees.

Note: #1823 covers the deep clone in stripConstructPath, a separate ~20-25% in the same code path. The two changes are independent and compose.

Checklist

• This change contains a major version upgrade for a dependency and I confirm all breaking changes are addressed
  • Release notes for the new version:

---

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license