WinUI 3 lifted Composition still uses the legacy FXC/DXBC shader pipeline and does not support DXC, Shader Model 6.9, DXIL, or D3D12U

### Describe the bug

The lifted `Microsoft.UI.Composition` implementation shipped with WinUI 3 still uses the legacy FXC/DXBC shader compilation and linking pipeline.

It does not support shaders compiled by the current DirectX Shader Compiler (DXC), including DXIL shaders targeting Shader Model 6.9, nor does the Composition effect backend expose a D3D12/D3D12U execution path.

This is separate from #11813. That issue reports the lack of a supported public custom-effect/custom-shader extension point. This issue concerns the outdated shader compiler and graphics backend used internally by lifted Composition. Even if a public custom-shader API were added, the current implementation would still be restricted to the legacy FXC/DXBC pipeline.

## Evidence from the shipped runtime

The following binaries were inspected from:

```text
Microsoft.WindowsAppSDK.InteractiveExperiences
Version: 2.1.7-experimental
Architecture: win-x64
Binary version: 10.0.27200.1049
```

Relevant files:

```text
runtimes-framework\win-x64\native\wuceffectsi.dll
runtimes-framework\win-x64\native\dwmcorei.dll
```

### `wuceffectsi.dll`

The Composition effect compiler explicitly loads:

```text
d3dcompiler_47.dll
```

and resolves:

```text
D3DCompile
D3DReflectLibrary
```

`Microsoft::UI::Composition::EffectGenerator::BuildCompiledEffectSubgraph` hard-codes the shader target:

```text
lib_4_0_level_9_3_ps_only
```

The generated HLSL is therefore compiled as a legacy D3D11 shader library using FXC-compatible DXBC.

There is no `dxcompiler.dll`, `DxcCreateInstance`, `IDxcCompiler`, `IDxcUtils`, or equivalent DXC/DXIL path in this component.

### `dwmcorei.dll`

The corresponding Composition rendering implementation imports the legacy D3DCompiler function-linking APIs:

```text
D3DLoadModule
D3DCreateLinker
D3DCreateFunctionLinkingGraph
D3DCreateBlob
```

The supported pixel-shader profiles visible in the binary are limited to:

```text
ps_4_0
ps_4_0_level_9_3
ps_4_0_level_9_1
```

The binary contains hundreds of embedded `DXBC` shader containers but no `DXIL` containers. The embedded shaders also identify the legacy Microsoft HLSL Shader Compiler.

This indicates that both sides of the lifted Composition effect pipeline are tied to the old D3D11 Function Linking/DXBC ABI:

```text
Generated HLSL
↓
D3DCompile / FXC
↓
lib_4_0_level_9_3_ps_only DXBC library
↓
D3DLoadModule / ID3D11Linker
↓
D3D11 Composition shader
```

A shader compiled with a current package such as:

```text
Microsoft.Direct3D.DXC 1.9.2607.13
```

using a target such as:

```text
ps_6_9
lib_6_9
```

produces DXIL, which cannot be consumed by the existing `D3DLoadModule` and `ID3D11Linker` pipeline.

Adding or updating the DXC NuGet package in the application does not help because shader compilation is performed internally by `wuceffectsi.dll`, which explicitly loads `d3dcompiler_47.dll` and chooses a fixed legacy target.

### Why is this important?

Can not use such as https://devblogs.microsoft.com/directx/shader-model-6-9-retail-and-more/

WinUI 3 presents lifted Composition as the current application-local Composition implementation, but its effect compiler remains tied to the deprecated FXC toolchain and very old shader profiles.

This is not merely a request for an additional visual effect. It prevents applications from using Microsoft's current HLSL compiler and shader platform in the current Windows UI framework, and creates an architectural blocker for the custom-material scenarios described in #11813.

### Steps to reproduce the bug

## Steps to reproduce the bug

1. Create a WinUI 3 application using `Microsoft.UI.Composition`.
2. Attempt to use a shader compiled by `Microsoft.Direct3D.DXC 1.9.2607.13` with a Shader Model 6.x target, including `ps_6_9` or `lib_6_9`.
3. Attempt to pass the resulting DXIL shader through a Composition custom-effect path or through the private effect/compiler path currently required because of #11813.
4. Observe that the DXIL shader cannot be loaded or linked by the Composition runtime.
5. Inspect the shipped Composition binaries and observe that the runtime loads `d3dcompiler_47.dll`, hard-codes `lib_4_0_level_9_3_ps_only`, and consumes shaders through legacy D3D11 Function Linking APIs.

### Actual behavior

WinUI 3 lifted Composition is restricted to:

```text
FXC
DXBC
Shader Model 4.x / Level 9.x profiles
D3D11 Function Linking
```

It does not provide a path for:

```text
DXC
DXIL
Shader Model 6.x, including Shader Model 6.9
D3D12/D3D12U-backed Composition effects
```

Applications therefore cannot use current HLSL language and compiler functionality, newer shader-model features, or a modern D3D12 shader backend in Composition effects.

Replacing `d3dcompiler_47.dll`, adding `Microsoft.Direct3D.DXC`, or changing the application’s shader build settings cannot solve the problem because the legacy target and linking ABI are implemented inside the private Composition runtime.

### Expected behavior

Lifted `Microsoft.UI.Composition` should provide a modern shader path based on DXC and DXIL.

At minimum, the runtime should:

1. Support shader bytecode produced by current `Microsoft.Direct3D.DXC` releases.
2. Support appropriate Shader Model 6.x targets, including Shader Model 6.9 where supported by the OS, adapter, and driver.
3. Avoid requiring legacy `D3DLoadModule`/`ID3D11Linker` function linking for modern shaders.
4. Provide a D3D12/D3D12U-backed Composition effect path, or document why lifted Composition remains restricted to D3D11.
5. Expose capability detection so applications can determine whether DXIL, a particular shader model, and the D3D12 backend are available.
6. Retain a legacy DXBC fallback only where required for older hardware or compatibility.

Together with the public extensibility requested in #11813, the intended path should be similar to:

```text
Application HLSL
↓
Microsoft.Direct3D.DXC
↓
DXIL / Shader Model 6.x
↓
supported Microsoft.UI.Composition custom-shader API
↓
D3D12/D3D12U lifted Composition backend
```

### Screenshots

_No response_

### NuGet package version

Microsoft.WindowsAppSDK.InteractiveExperiences 2.1.7-experimental (2.4.1) Microsoft.Direct3D.DXC 1.9.2607.13

### Windows version

_No response_

### Additional context

## Related issue

- #11813 — Lifted `Microsoft.UI.Composition` still rejects custom/D2D effects while MUC also lacks Visual-to-GPU interop

#11813 tracks the absence of a supported public entry point. This issue tracks the separate requirement to modernize the underlying Composition shader compiler, bytecode format, linking model, and graphics backend.

The affected Composition implementation is distributed as part of the Windows App SDK/WinUI runtime but does not appear to be included in the public `microsoft-ui-xaml` source tree. If the implementation is owned by another Windows graphics or Composition team, please transfer or route this issue rather than treating it as an application dependency-version problem.

Start by confirming ownership of the lifted Composition implementation, since the issue identifies shipped runtimes rather than public source files. Inspect wuceffectsi.dll and dwmcorei.dll for the cited compiler, shader-target, and linking entry points; done requires an agreed modern DXC/DXIL and backend plan, or documentation of the supported limitation.

Written by the indexing model from the issue text.