Julia 1.14 compatibility; CI step selection

[maleadt]

On main, nightly (1.14) fails in gpuarrays/uniformscaling (a broken module from jl_genericmemory_copyto in device code) and more.

• CI: [only X]/[skip X] take comma-separated step tags, as in GPUCompiler: julia, nightly, special, and tests for everything. Draft PRs only test the newest release (1.13) and nightly; older releases and the validation run once the PR is ready. Steps share their definition through YAML anchors. This also drops a duplicate if: key from the validation step.
• Bounds errors: the generic checkbounds (e.g. for views) now throws through Base._throw_boundserror_indices (Fix --trim compatibility for BoundsError JuliaLang/julia#61561), bypassing the throw_boundserror override. Overridden too, as in Metal.jl.
• Type broadcasts: 1.14 specializes type arguments on Core.TypeEgal{T} (type system: Add TypeEgal kind JuliaLang/julia#62001), which the Broadcasted{…, Type{T}} adaptor rule didn't match, so Float32.(x) failed to compile. It now matches <:Type{T}.
• Functions capturing a type: LinearAlgebra's triangular det now reduces with Base.Fix1(convert, T) (Check that matrix is square in det triangular fast-path JuliaLang/LinearAlgebra.jl#1658), which isn't isbits. Fix1/Fix2 capturing a type are converted to closures.

The uniformscaling failure itself is fixed in SPIRVIntrinsics (consistent overlays, JuliaGPU/OpenCL.jl#505), and the write-barrier failures in JuliaGPU/GPUCompiler.jl#956. With both, the full test suite passes locally on nightly (1.14.0-DEV.3363, Iris Xe). This PR now requires GPUCompiler 2.9. The last commit temporarily points [sources] at the OpenCL.jl branch; it'll be dropped once SPIRVIntrinsics is released.

[codecov]

Codecov Report

❌ Patch coverage is 12.50000% with 7 lines in your changes missing coverage. Please review.
✅ Project coverage is 80.73%. Comparing base (75237a5) to head (b5533fd).
⚠️ Report is 1 commits behind head on main.

Files with missing lines	Patch %	Lines
src/compiler/execution.jl	0.00%	4 Missing ⚠️
src/device/quirks.jl	25.00%	3 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #647      +/-   ##
==========================================
+ Coverage   80.63%   80.73%   +0.09%     
==========================================
  Files          55       56       +1     
  Lines        4034     4060      +26     
==========================================
+ Hits         3253     3278      +25     
- Misses        781      782       +1     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[github-actions]

Your PR requires formatting changes to meet the project's style guidelines.
Please consider running Runic (git runic main) to apply these changes.

Click here to view the suggested changes.

diff --git a/src/compiler/execution.jl b/src/compiler/execution.jl
index 20742c2..a04c44c 100644
--- a/src/compiler/execution.jl
+++ b/src/compiler/execution.jl
@@ -158,15 +158,20 @@ Adapt.adapt_structure(to::KernelAdaptor, r::Base.RefValue{<:Union{DataType,Type}
 # case where type is the function being broadcasted
 # (on Julia 1.14, the function type parameter is `Core.TypeEgal{T} <: Type{T}`)
 Adapt.adapt_structure(to::KernelAdaptor,
-                      bc::Broadcast.Broadcasted{Style, <:Any, <:Type{T}}) where {Style, T} =
+    bc::Broadcast.Broadcasted{Style, <:Any, <:Type{T}}
+) where {Style, T} =
     Broadcast.Broadcasted{Style}((x...) -> T(x...), adapt(to, bc.args), bc.axes)
 
 # functions that capture a type, e.g., `Base.Fix1(convert, T)` as used by LinearAlgebra,
 # which isn't a valid kernel argument either
 Adapt.adapt_structure(to::KernelAdaptor, f::Base.Fix1{<:Any, <:Type{T}}) where {T} =
-    let g = adapt(to, f.f); (x...) -> g(T, x...) end
+let g = adapt(to, f.f)
+    (x...) -> g(T, x...)
+end
 Adapt.adapt_structure(to::KernelAdaptor, f::Base.Fix2{<:Any, <:Type{T}}) where {T} =
-    let g = adapt(to, f.f); (x...) -> g(x..., T) end
+let g = adapt(to, f.f)
+    (x...) -> g(x..., T)
+end
 
 """
     kernel_convert(x)