[Lint]Style: Convert vllm-ascend/compilation to ruff format (#5912)

### What this PR does / why we need it?
Convert `vllm-ascend/compilation` to ruff format.

### Does this PR introduce _any_ user-facing change?
During this migration, we encountered some **errors** in our CI and
testing environments, such as:
```
vllm_ascend/utils.py:653: in <module>
    def register_ascend_customop(vllm_config: VllmConfig | None = None):
                                              ^^^^^^^^^^^^^^^^^
E   TypeError: unsupported operand type(s) for |: 'NoneType' and 'NoneType'
```

**1. Root Cause Analysis:**
The project uses a common pattern to break circular dependencies:
```python
if TYPE_CHECKING:
    from vllm.config import VllmConfig
else:
    VllmConfig = None  # Placeholder assigned at runtime
```
When Python parses the function definition `def
register_ascend_customop(vllm_config: VllmConfig | None)`, it attempts
to evaluate the expression `VllmConfig | None`.
Since `VllmConfig` is assigned `None` at runtime, the expression
effectively becomes `None | None`. In Python, `None` is an instance of
`NoneType`. While the `|` operator is implemented for Type objects
(classes), it is not supported for `NoneType` instances, leading to the
`TypeError` shown above.

**2. Solution:**
To maintain the modern `|` syntax required by our new linting standards
while preserving our dependency management strategy, I have introduced:
```python
from __future__ import annotations
```
at the top of the affected files. This enables **Postponed Evaluation of
Annotations (PEP 563)**.

**3. Impact and Benefits:**
- By enabling `annotations`, Python no longer executes the `VllmConfig |
None` operation during module load. Instead, it stores the annotation as
a string literal, completely avoiding the `None | None` calculation.
- We can keep the `VllmConfig = None` placeholders. This ensures that
other modules can still import these symbols without triggering an
`ImportError`, maintaining a stable dependency graph.
- IDEs and static type checkers (MyPy/Pyright) continue to resolve the
types correctly. This allows us to use modern syntax without sacrificing
type safety or runtime stability.
- The only side effect is that `__annotations__` will now return strings
instead of type objects. Since this module does not use runtime type
enforcement or reflection, this change has zero negative impact on
existing functionality.
### How was this patch tested?

- vLLM version: v0.13.0
- vLLM main:
11b6af5280

---------

Signed-off-by: MrZ20 <2609716663@qq.com>

vllm_ascend/flash_common3_context.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 import torch
 from vllm.model_executor.layers.linear import LinearBase
@@ -7,26 +6,26 @@ from vllm.model_executor.layers.linear import LinearBase
 
 @dataclass
 class FlashCommon3Context:
-    gate: Optional[LinearBase] = None
-    topk_weights: Optional[torch.Tensor] = None
-    topk_ids: Optional[torch.Tensor] = None
-    row_idx: Optional[torch.Tensor] = None
-    shared_experts: Optional[torch.nn.Module] = None
-    shared_out: Optional[torch.Tensor] = None
+    gate: LinearBase | None = None
+    topk_weights: torch.Tensor | None = None
+    topk_ids: torch.Tensor | None = None
+    row_idx: torch.Tensor | None = None
+    shared_experts: torch.nn.Module | None = None
+    shared_out: torch.Tensor | None = None
 
 
-_flash_common3_context: Optional[FlashCommon3Context] = None
+_flash_common3_context: FlashCommon3Context | None = None
 
 
-def get_flash_common3_context() -> Optional[FlashCommon3Context]:
+def get_flash_common3_context() -> FlashCommon3Context | None:
     return _flash_common3_context
 
 
 def set_flash_common3_context(
-    topk_weights: Optional[torch.Tensor] = None,
-    topk_ids: Optional[torch.Tensor] = None,
-    shared_experts: Optional[torch.nn.Module] = None,
-    shared_out: Optional[torch.Tensor] = None,
+    topk_weights: torch.Tensor | None = None,
+    topk_ids: torch.Tensor | None = None,
+    shared_experts: torch.nn.Module | None = None,
+    shared_out: torch.Tensor | None = None,
 ):
     global _flash_common3_context
     if _flash_common3_context is None: