Correct when fixpoint-fixed type variables can be reunified

With fixpoint-fixing, we don't want to re-unify type variables that were
just fixed, because doing so may change their shapes in ways that we
explicitly just set them up not to be changed (as fixpoint-fixing
clobbers type variable contents).

However, this restriction need only apply when we re-unify two type
variables that were both involved in the same fixpoint-fixing cycle. If
we have a type variable T that was involved in fixpoint-fixing, and we
unify it with U that wasn't, we know that the $U \notin \bar{T}$, where
$\bar{T}$ is the recursive closure of T. In these cases, we do want to
permit the usual in-band unification of $T \sim U$.

crates/compiler/solve/tests/solve_expr.rs

@@ -8283,4 +8283,41 @@ mod solve_expr {
             "MDict v -> MDict v | v has Eq",
         );
     }
+
+    #[test]
+    fn unify_types_with_fixed_fixpoints_outside_fixing_region() {
+        infer_queries!(indoc!(
+            r#"
+            app "test" provides [main] to "./platform"
+
+            Input := [
+                FromJob Job
+            ]
+
+            Job := [
+                Job (List Input)
+            ]
+
+            job : List Input -> Job
+            job = \inputs ->
+                @Job (Job inputs)
+
+            helloWorld : Job
+            helloWorld =
+                @Job ( Job [ @Input (FromJob greeting) ] )
+                #            ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+            greeting : Job
+            greeting =
+                job []
+
+            main = (\_ -> "Which platform am I running on now?\n") helloWorld
+            "#
+        ),
+        @r###"
+        @Input (FromJob greeting) : [FromJob ([Job (List [FromJob a])] as a)]
+        "###
+        print_only_under_alias: true
+        )
+    }
 }