fix(#1493): build self.upstream lazily; stop reloading deps per populate key

[dimitri-yatsenko]

Fixes the per-make() cost profiled in #1493 (~53 ms and ~59 information_schema round-trips per populate key, even when make() never reads self.upstream).

1. Lazy self.upstream (autopopulate.py): _populate1 records the make() key (_upstream_key) instead of eagerly building Diagram.trace(). The trace is built on first self.upstream access and memoized for the call, so make() calls that never touch upstream pay nothing. Both _upstream and _upstream_key are cleared in finally.

2. Idempotent dependency loading (dependencies.py): track _loaded_schemas; load_all_upstream/load_all_downstream skip the full information_schema rebuild when the graph already contains every needed schema — so repeated Diagram.trace() calls within one populate() don't reload the dependency tree per key.

Tests: three self.upstream tests pinned the old eager internal (self._upstream non-None throughout make); updated to the lazy contract. One now asserts self._upstream stays None when make() never reads upstream (proving laziness); the tripartite test captures id(self.upstream) (the property) to verify one shared object across phases. Locally: 6/6 upstream + 76 trace/cascade/delete/erd tests pass on MySQL and PostgreSQL.

Closes #1493.

[MilagrosMarin]

Thanks @dimitri-yatsenko — clean two-part fix for #1493. Verified end-to-end:

1. Lazy self.upstream (autopopulate.py). _populate1 now sets _upstream_key = dict(key) and _upstream = None before invoking make(); the property builds Diagram.trace(self & self._upstream_key) on first access and memoizes. The "outside make()" gate is correctly switched from _upstream is None to _upstream_key is None — otherwise the very first access inside make() would raise. finally clears both. Tripartite path (fetch/compute/insert with the generator restart at line 720) shares the same _upstream slot across phases, so id(self.upstream) stays stable — the updated test assertion holds.

2. Idempotent dep loading (dependencies.py). _loaded_schemas tracks what's in the graph; load_all_upstream/load_all_downstream short-circuit when _loaded and known_schemas ⊆ _loaded_schemas. Correctness cases hold: first call (unloaded) → reload; repeated call with same schemas → skip; discovery finds a new schema → superset check fails → reload; clear() resets both fields. load() continues to unconditionally repopulate _loaded_schemas, so direct load(force=True, ...) callers still get a fresh graph.

Test updates are on-point. test_upstream_cleared_after_make now asserts self._upstream is None inside the make() body that doesn't read upstream — that's the specific regression guard for the laziness claim, and it would fail against the old eager code. The tripartite test's switch from id(self._upstream) to id(self.upstream) correctly captures the property (which triggers the memoized build) rather than the raw internal attribute.

Two small observations, neither blocking:

• No test for the dep-loading idempotence itself. A query-count assertion (information_schema round-trips = N on first Diagram.trace(), 0 on repeats) would concretely pin the perf fix — otherwise a future refactor could break the short-circuit silently. The existing tests cover correctness; this would cover the perf guarantee the PR's motivation rests on.
• Private-attribute contract shifted. self._upstream is None no longer discriminates "outside make()" — self._upstream_key does. Since these are underscore-prefixed with no stability promise, this is fine; the test file itself updated to the new discriminator. Just worth being aware if any external code (plugin, extension, or user script) introspected _upstream for that signal.

Approving.