Support implicit capability declarations per SPIR-V spec

Per the spec's Capability table "Implicitly Declares" column, declaring
a capability transitively declares its dependencies. For example,
declaring GroupNonUniformArithmetic implicitly declares GroupNonUniform.

Add expand_implicit_capabilities() which computes the transitive closure
using grammar data, matching the C++ validator's RegisterCapability().

Also refactor capabilities.rs:
- Extract validate_capabilities into focused helper functions
- Remove dead code (is_soft_dependency, required_capabilities_for_capability)
- Make internal helpers private (aliases, is_vendor_extension, etc.)
- Rename functions for clarity (required_extension, required_version)
- Deduplicate capability extraction via collect_explicit_capabilities
- Simplify capability_operand and capability_satisfied
- Update tests to expect success for implicit declarations

Author: LegNeato

rust/spirv-tools-core/src/validation/helpers.rs

@@ -535,18 +535,14 @@ pub fn collect_result_types(module: &Module) -> Result<HashMap<ResultId, TypeId>
     Ok(result)
 }
 
-/// Collects all declared capabilities.
+/// Collects all declared capabilities, including implicitly declared ones.
+///
+/// Per the SPIR-V spec, declaring a capability implicitly declares its
+/// dependencies (transitively). This function returns the effective set.
 pub fn collect_declared_capabilities(module: &Module) -> HashSet<Capability> {
-    module
-        .capabilities
-        .iter()
-        .filter_map(|inst| {
-            inst.operands.first().and_then(|op| match op {
-                Operand::Capability(cap) => Some(*cap),
-                _ => None,
-            })
-        })
-        .collect()
+    use super::rules::capabilities::{collect_explicit_capabilities, expand_implicit_capabilities};
+
+    expand_implicit_capabilities(&collect_explicit_capabilities(module))
 }
 
 // ============================================================================

rust/spirv-tools-core/src/validation/mod.rs

@@ -92,8 +92,7 @@ use helpers::{
     collect_result_opcodes, collect_result_types, is_memory_object_declaration,
 };
 use rules::capabilities::{
-    capability_operand, capability_satisfied, required_extension_for_capability,
-    validate_capabilities,
+    capability_operand, capability_satisfied, required_extension, validate_capabilities,
 };
 use rules::extensions::{
     extension_operand, extension_satisfied, has_extension, validate_extension_allowlist,
@@ -911,7 +910,7 @@ fn validate_instruction_requirements(
                 // Also check if any of the instruction's required capabilities have enabling extensions
                 let has_extension_from_cap = !inst.class.capabilities.is_empty()
                     && inst.class.capabilities.iter().any(|&cap| {
-                        if let Some(ext) = required_extension_for_capability(cap) {
+                        if let Some(ext) = required_extension(cap) {
                             extension_satisfied(ext, extensions, target_version)
                         } else {
                             false