Fix net472 out-of-proc tests crashing on servicing binding-redirect skew

Test projects that re-bundle MSBuild.exe (via ProjectReference to MSBuild.csproj)
copy the servicing MSBuild.exe.config but resolve their own copy-local runtime
assemblies at the compiled-against versions. The redirects then point at servicing
versions (e.g. System.Memory 4.0.5.0) while the on-disk assembly is the
compiled-against one (4.0.2.0), so the copied MSBuild.exe fails to start with a
TypeInitializationException/FileLoadException. This broke every net472 out-of-proc
test and hung tests waiting on a spawned node/server until the CI timeout.

Add an AfterTargets="Build" target (net472, non-deploy projects only) that realigns
the copied MSBuild.exe.config binding redirects to the runtime assemblies actually
present next to it, keeping those bins self-consistent at the compiled-against
versions. Deploy surfaces (MSBuild.exe, bootstrap) are excluded since their output
already is the servicing build.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: JanProvaznik

src/Directory.Build.targets

@@ -296,6 +296,106 @@
     </ItemGroup>
   </Target>
 
+  <!--
+    The net472 servicing redistribution above swaps DLLs and updates the binding redirects only in
+    the projects that opt in ($(DeployRuntimeServicingAssemblies) == 'true': MSBuild.exe and the
+    bootstrap). Other net472 projects that re-bundle MSBuild.exe (the test projects that spawn it
+    out-of-proc, e.g. via ProjectReference to MSBuild.csproj) copy MSBuild.exe.config (which now
+    carries the servicing redirects) but resolve their own copy-local runtime assemblies at the
+    compiled-against versions. That leaves MSBuild.exe.config pointing at servicing versions
+    (e.g. System.Memory 4.0.5.0) while the assembly on disk is the compiled-against one
+    (4.0.2.0), so the copied MSBuild.exe fails to start with a FileLoadException, breaking every
+    out-of-proc test (and hanging tests that wait on a spawned node/server).
+
+    These bins are not a VS redistribution surface, so the fix is to keep them self-consistent at
+    the compiled-against versions: realign the copied MSBuild.exe.config binding redirects to the
+    runtime assemblies actually next to it. Deploy surfaces are excluded; their DLLs already are
+    the servicing build, so realigning would be a no-op there anyway.
+  -->
+  <UsingTask TaskName="AlignBindingRedirectsToOutputAssemblies"
+             AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll"
+             TaskFactory="RoslynCodeTaskFactory">
+    <ParameterGroup>
+      <ConfigFiles ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
+    </ParameterGroup>
+    <Task>
+      <Code Type="Fragment" Language="cs"><![CDATA[
+        System.Xml.Linq.XNamespace ns = "urn:schemas-microsoft-com:asm.v1";
+        foreach (Microsoft.Build.Framework.ITaskItem item in ConfigFiles)
+        {
+            string configPath = item.ItemSpec;
+            if (!System.IO.File.Exists(configPath))
+            {
+                continue;
+            }
+
+            string directory = System.IO.Path.GetDirectoryName(configPath);
+            System.Xml.Linq.XDocument document = System.Xml.Linq.XDocument.Load(configPath);
+            bool changed = false;
+
+            foreach (System.Xml.Linq.XElement dependentAssembly in document.Descendants(ns + "dependentAssembly"))
+            {
+                System.Xml.Linq.XElement identity = dependentAssembly.Element(ns + "assemblyIdentity");
+                System.Xml.Linq.XElement redirect = dependentAssembly.Element(ns + "bindingRedirect");
+                if (identity == null || redirect == null)
+                {
+                    continue;
+                }
+
+                string name = (string)identity.Attribute("name");
+                if (string.IsNullOrEmpty(name))
+                {
+                    continue;
+                }
+
+                string assemblyPath = System.IO.Path.Combine(directory, name + ".dll");
+                if (!System.IO.File.Exists(assemblyPath))
+                {
+                    continue;
+                }
+
+                string version;
+                try
+                {
+                    version = System.Reflection.AssemblyName.GetAssemblyName(assemblyPath).Version.ToString();
+                }
+                catch (System.Exception)
+                {
+                    continue;
+                }
+
+                redirect.SetAttributeValue("oldVersion", "0.0.0.0-" + version);
+                redirect.SetAttributeValue("newVersion", version);
+
+                System.Xml.Linq.XElement codeBase = dependentAssembly.Element(ns + "codeBase");
+                if (codeBase != null)
+                {
+                    codeBase.SetAttributeValue("version", version);
+                }
+
+                changed = true;
+            }
+
+            if (changed)
+            {
+                document.Save(configPath);
+                Log.LogMessage(Microsoft.Build.Framework.MessageImportance.Normal, "Aligned binding redirects in '{0}' to the runtime assemblies in its output directory.", configPath);
+            }
+        }
+      ]]></Code>
+    </Task>
+  </UsingTask>
+
+  <Target Name="AlignCopiedMSBuildExeConfigBindingRedirects"
+          AfterTargets="Build"
+          Condition="'$(TargetFramework)' == 'net472' and '$(DeployRuntimeServicingAssemblies)' != 'true'">
+    <ItemGroup>
+      <_CopiedMSBuildExeConfig Include="$(TargetDir)**\MSBuild.exe.config" />
+    </ItemGroup>
+    <AlignBindingRedirectsToOutputAssemblies ConfigFiles="@(_CopiedMSBuildExeConfig)"
+                                             Condition="'@(_CopiedMSBuildExeConfig)' != ''" />
+  </Target>
+
   <!-- Import parent targets -->
   <Import Project="..\Directory.Build.targets"/>