This PR is a bit speculative; we think that the lazy property getters we
inject to avoid having to read all files of the entire `aws-cdk-lib`
library upon module loading (so to speed up
time-to-executing-first-statement) is adding significant overhead for
programs with a large number of statements.

Roughly:

```ts
// This avoids having to read the './core' module at startup, only do it
// if and when 'AspectPriority' gets accessed
Object.defineProperty(exports, "AspectPriority", { get: () => require("./core").AspectPriority });
```

However, the result of this is that every property access requires
running one or more getters (one for every level of indirecting file).
This may have a noticeable effect, on the order of ~1us per property
access.

To cut down on that, we will do the lazy getters differently: after
the initial lazy load, we overwrite the getter with the actual value.
That way subsequent accesses can bypass the getters and be fast:

```ts
// Only execute getter on first access
Object.defineProperty(exports, "AspectPriority", { get: () => {
  const value = require("./core").AspectPriority;

  // Overwrite getter with real value once we have it
  Object.defineProperty(exports, "AspectPriority", { value });

  return value;
});
```

This should achieve both goals of fast initial load and high throughput
for subsequent accesses.