Add value-based oneOf/anyOf discrimination

Problem

ogen currently rejects schemas where oneOf/anyOf variants have the same field name and JSON type, even when enum values are different:

oneOf:
  - properties:
      status: { enum: ["active", "pending"] }
  - properties:
      status: { enum: ["inactive", "deleted"] }

Error: type-based discrimination with same jxType

This blocks common patterns: status-based APIs, event systems with eventType enums, Kubernetes-style resource types, and state machines.

Solution

Adds value-based discrimination as a 5th automatic discrimination strategy. When variants share a field name and JSON type but have different enum values, ogen now:

1. Finds a field with disjoint enum values across variants
2. Skips fields with overlapping enum values if another field can discriminate
3. Generates a switch statement on enum string values
4. Automatically discriminates variants at runtime based on the enum value

Example generated code for status field:

case "status":
    value, _ := d.StrBytes()
    switch string(value) {
    case "active", "pending":
        s.Type = ActiveStatusResponse
    case "inactive", "deleted":
        s.Type = InactiveStatusResponse
    }

Overlapping Values Handling

When one field has overlapping enum values but another field can discriminate, ogen uses the discriminating field:

# Works: carrier field discriminates, signature overlap is ignored
oneOf:
  - properties:
      carrier: { enum: [usps] }
      signature: { enum: [gift, sample] }  # overlapping with FedEx
  - properties:
      carrier: { enum: [fedex] }
      signature: { enum: [gift, express] }  # overlapping with USPS

Testing

• 3 positive scenarios: Basic enum discrimination, multiple discriminating fields, mixed discrimination strategies
• Overlapping values scenario: When one field has overlapping enum values but another field can discriminate, uses the discriminating field (ShippingOption test case)
• 1 negative scenario: Validates overlap detection with clear error messages when NO field can discriminate
• Integration tests: All existing tests pass (2585+ core tests), new test suite added
• Example tests: All pass including ex_github (GitHub API spec edge cases)

Changes

• gen/ir/type.go: Added ValueDiscriminator metadata structure
• gen/schema_gen_sum.go: Added detection and validation logic (~150 lines)
• gen/_template/json/encoders_sum.tmpl: Added value discrimination template
• gen/ir/faker.go: Fixed faker to skip parent fields that overlap with oneOf variant fields (prevents duplicate JSON keys)
• README.md: Documented new discrimination strategy
• Tests: Added comprehensive positive and negative test specs

Backward Compatibility

✅ No breaking changes. Purely additive:

• Schemas that previously failed now succeed
• Schemas that previously worked continue working unchanged
• All existing tests pass (2585+ core tests)

Related Issues

May help with #491 (anyOf discriminator support), #1230 (oneOf decode), #1480 (nested sum types).

Complements commit 40e0719 which added type-based discrimination.

Performance

String value checking is O(n) for n enum values, but:

• Typical enum sets are 2-10 values (negligible impact)
• Generated switch statements are compiler-optimized
• Type-based discrimination still runs first (higher priority)