Make Union deserialization algorithm more robust

[Fatal1ty]

Closes #42, #221, #252, #255

This PR brings a new type of expression TypeMatchEligibleExpression. It conveys that the expression built for a ValueSpec is eligible for direct processing the value if the type matches, but doesn’t guarantee that it will always be processed that way. This information is used in Union deserialization algorithm to return the input value as is only when its type is in the list of expected types. The order of variant types still matters. The following value types will have TypeMatchEligibleExpression:

• str
• bool
• int
• float
• NoneType

If the input value type doesn't match any of the expected types, it will be processed as before or as written below.

This PR also changes the way how str, bool and NoneType values are processed on deserialization outside on Union:

• Expected str value will processed as str(value)
• Expected bool value will be processed as bool(value)
• Expected NoneType value will always be None regardless of the input value

Some examples:

@dataclass
class Foo(DataClassDictMixin):
    foo: str | int

Foo.from_dict({"foo": "1"})  # Foo(foo="1")
Foo.from_dict({"foo": 1})    # Foo(foo=1)

@dataclass
class Foo(DataClassDictMixin):
    foo: int | str

Foo.from_dict({"foo": "1"})  # Foo(foo="1")
Foo.from_dict({"foo": 1})    # Foo(foo=1)

@dataclass
class Foo(DataClassDictMixin):
    foo: str | date

Foo.from_dict({"foo": "2024-11-11"})  # Foo(foo="2024-11-11")

@dataclass
class Foo(DataClassDictMixin):
    foo: date | str

Foo.from_dict({"foo": "2024-11-11"})  # Foo(foo=date(2024, 11, 11))

@dataclass
class Foo(DataClassDictMixin):
    foo: int | float

Foo.from_dict({"foo": 1})      # Foo(foo=1)
Foo.from_dict({"foo": 1.0})    # Foo(foo=1.0)
Foo.from_dict({"foo": "1"})    # Foo(foo=1)
Foo.from_dict({"foo": "1.0"})  # Foo(foo=1.0)

@dataclass
class Foo(DataClassDictMixin):
    foo: float | int

Foo.from_dict({"foo": 1})      # Foo(foo=1)
Foo.from_dict({"foo": 1.0})    # Foo(foo=1.0)
Foo.from_dict({"foo": "1"})    # Foo(foo=1)
Foo.from_dict({"foo": "1.0"})  # Foo(foo=1.0)

@dataclass
class Foo(DataClassDictMixin):
    foo: bool | int

Foo.from_dict({"foo": 1})          # Foo(foo=1)
Foo.from_dict({"foo": True})       # Foo(foo=True)
Foo.from_dict({"foo": "1"})        # Foo(foo=True)
Foo.from_dict({"foo": [1, 2, 3]})  # Foo(foo=True)
Foo.from_dict({"foo": "1.2"})      # Foo(foo=True)
Foo.from_dict({"foo": [1, 2, 3]})  # Foo(foo=True)

@dataclass
class Foo(DataClassDictMixin):
    foo: int | bool

Foo.from_dict({"foo": 1})          # Foo(foo=1)
Foo.from_dict({"foo": True})       # Foo(foo=True)
Foo.from_dict({"foo": "1"})        # Foo(foo=1)
Foo.from_dict({"foo": [1, 2, 3]})  # Foo(foo=True)
Foo.from_dict({"foo": "1.2"})      # Foo(foo=True)
Foo.from_dict({"foo": [1, 2, 3]})  # Foo(foo=True)

@dataclass
class Foo(DataClassDictMixin):
    foo: type(None)

Foo.from_dict({"foo": 1})      # Foo(foo=None)
Foo.from_dict({"foo": "bar"})  # Foo(foo=None)

@dataclass
class Foo(DataClassDictMixin):
    foo: tuple[type(None), type(None), type(None)]

Foo.from_dict({"foo": [1, 2, 3]})  # Foo(foo=(None, None, None))