[Module Explorer] Enum members are counted as untyped even though annotations are forbidden

[rayliverified]

Summary

Module Explorer counts valid Enum/StrEnum members as untyped because they do not have explicit annotations. However, PEP 435 enum members are inferred from their assignments and must be left unannotated. Basilisk's own enums_members diagnostic correctly rejects the annotation that would otherwise satisfy the coverage metric.

This makes the type-coverage percentage impossible to reach 100% in projects that use enums correctly.

Minimal reproduction

from enum import StrEnum


class Status(StrEnum):
    ACTIVE = "active"
    INACTIVE = "inactive"

Steps to reproduce

1. Open the file in a Basilisk workspace.
2. 2. Run basilisk check — it passes.
3. 3. Expand the module and Status in Module Explorer.
4. 4. Observe that ACTIVE and INACTIVE are labeled untyped and reduce the module/workspace coverage percentage.
5. 5. Attempt to add an explicit annotation:

class Status(StrEnum):
    ACTIVE: str = "active"

6. Run basilisk check again.

Actual behavior

The valid plain enum members are counted as untyped. Adding an annotation produces the expected error:

error[enums_members]: Enum member `ACTIVE` in `Status` should not have an explicit type annotation

The diagnostic correctly notes that enum members have an inferred Literal[Status.ACTIVE] type.

Expected behavior

Enum members should either:

1. Count as typed using their inferred Literal[EnumClass.MEMBER] type, or
2. 2. Be excluded from the explicit-annotation coverage denominator.
      The coverage metric should not require syntax that the type specification and Basilisk itself prohibit.

Impact

In a real Python 3.12 project, Module Explorer reports 33 enum members as untyped across otherwise fully annotated modules. This lowers raw workspace coverage and forces downstream coverage gates to special-case enum members.

Environment

• Basilisk / VS Code extension: 0.38.0
• • Python: 3.12
• • • OS: Windows

[rayliverified]

Another thing to note, would it make sense to add an option to turn off explicit symbol types?
Basilisk requires variables with inferred types to be explicitly typed, otherwise it considers it "untyped", even though in Python 3.12 type can be inferred for abc = "string"