Could we use

Oh no. It doesn't seem to support circular references.
jonschlinkert/clone-deep#23

Well, the old JSON-based solution doesn't either. It's used to clone an AST, so it's expected to not have cycles.

You are right!
However I suspect clone-deep will corrupt the same reference.
lodash/lodash#2725

Also regarding the failure in ci, clone-deep only works on PlainObject, our ast object returns false in isPlainObject, so nothing changes.

Would it be possible for babel itself to use the structuredClone polyfill from core-js in versions of Node.js without native support (it's a recent addition)?

Theoretically yes, but I haven't tried it.

We don't need something as advanced as structuredClone, a simpler argoritm for trees is enough.

Uhm, the clone-deep package is simple enough that we can just copy it's code removing the isPlainObject check.

v8=require("v8")
a={}
b={x:a,y:a}
c=v8.deserialize(v8.serialize(a))
console.log(c.x==c.y,c.x==b.x)

true false

Our comments need to keep the same object reference.

Good catch, comments. Something like this? Our AST is a really simple structure, we don't need a complex cloning function

function deepClone(value, cache = new WeakMap) {
  if (typeof value === "object" && value !== null) {
    if (cache.has(value)) return cache.get(value);
    let cloned;
    if (Array.isArray(value)) {
      cloned = Array.from(value, elem => deepClone(elem, cache));
    } else {
      cloned = {};
      Object.keys(value).forEach(key => cloned[key] = deepClone(value[key], cache));
    }
    cache.set(value, cloned);
    return cloned;
  }
  return value;
}

This doesn't seem to be necessary:

The problem is that T must be the union of all the types of the nested objects of value (since the cache Map potentially contains all of them), so "this function returns T" isn't much useful.

Yes, this is an internal implementation that is not exported.