Pick latest pgjsonb get_fun return by alter_time, not by MAX(jid)

[co-cy]

Depends on #69063. This branch is layered on top of that PR; the diff currently shows both commits and will rebase to a single commit once #69063 is merged.

What does this PR do?

salt/returners/pgjsonb.py:get_fun chose the latest return per minion with MAX(jid). That is the lexicographic maximum of the jid column, not the time-latest return. It happens to coincide for Salt's default jid format (YYYYMMDDHHMMSSffffff) and the nano variant — both are timestamp-formatted strings of equal length, so lex order matches chronological. It silently breaks for any deployment where that assumption does not hold:

• master_job_cache.gen_jid is overridden with a custom scheme — UUIDs, snowflake ids, hash-based identifiers — none lexicographically sortable as timestamps.
• External publishers (salt-api, salt-ssh, orchestrate runners) call prep_jid(passed_jid="...") with a custom jid string.
• A master spans a jid_format config change and ends up with rows of different formats in the same salt_returns.

In all those cases MAX(jid) returns a row that is not the time-latest, and get_fun reports the wrong full_ret per minion. No exception, no warning — just a silently wrong answer.

This PR replaces the lex-max algorithm with ORDER BY alter_time DESC and DISTINCT ON (id). alter_time is populated by Postgres via DEFAULT NOW(), so "latest" reflects actual insertion order regardless of jid format.

What issues does this PR fix or reference?

Fixes #69064

Previous Behavior

sql = """SELECT s.id, s.jid, s.full_ret
         FROM salt_returns s
         JOIN (SELECT MAX(jid) AS jid
               FROM salt_returns GROUP BY fun, id) max
         ON s.jid = max.jid
         WHERE s.fun = %s
         """

For two returns of the same fun on the same minion with custom jids "abc-001" and "000-002" (chronologically the second is newer), MAX(jid) picks "abc-001" — wrong.

New Behavior

sql = """SELECT DISTINCT ON (id)
                id, jid, full_ret
         FROM salt_returns
         WHERE fun = %s
         ORDER BY id, alter_time DESC
         """

alter_time DESC orders by Postgres-managed insertion timestamp; DISTINCT ON (id) keeps the first row per minion. The chronologically newest return wins regardless of jid format.

Performance

There is no index on salt_returns.alter_time in the documented schema, so this query remains a sequential scan — same as the previous MAX(jid) GROUP BY form. Adding an alter_time index, alongside several other schema observations (jids.created_at, redundant GIN indexes, salt_returns.success typing), will be tracked as a separate follow-up RFC.

Merge requirements satisfied?

• Docs (no user-facing change; not required)
• Changelog — changelog/69064.fixed.md
• Tests written/updated — see tests/pytests/unit/returners/test_pgjsonb.py:
  • test_get_fun_orders_by_alter_time_desc_not_max_jid — pins the algorithm: SQL must order by alter_time DESC and must not contain MAX(jid).

Commits signed with GPG?

No.