fix #29936, precompile should not assume UnionAlls have stable addresses

[JeffBezanson]

typejoin can re-form a type like Val{x} where x, re-using Val.var and Val.body but allocating a new UnionAll. However, jl_serialize_datatype compares the address of the inner type (Val.body) while the code for serializing UnionAll compares the address of the UnionAll itself, leading to a possible inconsistency. This makes them both use the inner type, which has a stable address.

Backportable like whoa.

[vtjnash]

This appears to assert that unwrap(a) === unwrap(b) implies that a === b. That seems odd, but I guess does happen to be true most of the time. But that seems a bit strange because this PR then seems to be explicitly falsifiable per #29936 demonstrating that that assumed implication is bad.

[JeffBezanson]

The problem here is that there is a special serialization for unwrap(typename.wrapper), which jl_serialize_datatype detects by comparing the address of the DataType. So we serialized Val{x} where x such that the inner Val{x} got that special representation, but the UnionAll didn't match so it and its TypeVar were saved separately. So the deserializer constructed Val{x} where x, where the inner and outer x are different TypeVar objects, which is a malformed type. The intent of this change is to remove that discrepancy.

Another way to look at it is that if a::UnionAll === b::UnionAll is true, that does not imply that the addresses of a and b are the same, so comparing the addresses in C doesn't quite do what we want.

[vtjnash]

Right, I understand that's why this hides the bug. But just pointing out that it seems to potentially indicate a deeper issue, where we assume that TypeVar identity will be correctly maintained, but doesn't.

[vtjnash]

This is an example of what this PR could cause to fail (if it appeared in user code):

diff --git a/test/precompile.jl b/test/precompile.jl
index ed93b60bfd..d3417bfc8f 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -135,6 +135,8 @@ try
 
               const x28297 = Result(missing)
 
+              const d28297a = UnionAll(Dict.var, UnionAll(Dict.body.var, Dict.body.body)) # === Dict
+              const d28297b = UnionAll(Dict.body.var, UnionAll(Dict.var, Dict.body.body)) # === Dict{K,V} where K where V !== Dict
 
               # issue #28998
               const x28998 = [missing, 2, missing, 6, missing,
@@ -186,6 +188,8 @@ try
         @test Foo.abigint_x::BigInt + 1 == big"125"
 
         @test Foo.x28297.result === missing
+        @show Foo.d28297a # === Dict
+        @show Foo.d28297b # === Dict
 
         @test Foo.x28998[end] == 6
     end