Introduce safe enum + serde

[huykingsofm]

Problem

• Int enum has a problem: it's easy to create an invalid enum by accident. For example:

type role any
type Role = enum.RichEnum[role]

const (
    RoleUser = iota
    RoleAdmin
)

var (
    _ = enum.Map(RoleUser, "user")
    _ = enum.Map(RoleAdmin, "admin")
)

var invalidRole = Role(42)

Solution
SafeEnum: provides a type-safe enum. However, it doesn't support deserialization natively. This is the reason why Serde is created.
Serde: A wrapper provides functionality for serializing and deserializing enums that cannot be directly serialized or deserialized.

Example

// Define enum's underlying type.
type unsafeRole any

// Create a SafeEnum type for roles.
type Role = safeenum.SafeEnum[unsafeRole]

// Define specific enum values for the Role type.
// The second type parameter is known as the positioner. Note that each enum
// must have a unique positioner; no two enums can share the same positioner.
var (
    RoleUser  = safeenum.New[unsafeRole, safeenum.P0]("user")
    RoleAdmin = safeenum.New[unsafeRole, safeenum.P1]("admin")
    _         = enum.Finalize[Role]() // Optional: ensure no new enum values can be added to Role.
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    
    // Use enum.Serde due to the designation of SafeEnum, as it cannot be directly deserialized.
    Role enum.Serde[Role] `json:"role"`
}