add match_ty based on cast_fns

[clouds56]

Fixes #35.

This PR is based on #36, I'd like to perform rebase when #36 landed.

• add try_cast_from, get_cast_fns for TryCast*
• every TryCast trait should implemented CAST_METHOD (just for test, tell which trait is actually calling on), can_cast, unchecked_from and unchecked_to, other methods would derived from these methods
• add can_cast!, get_cast_fns! and match_ty! macros

type From = u8;
type To = u8;

assert!(can_cast!(From, To));

if let Some((from, to)) = get_cast_fns!(From, To) {
  assert_eq!(from(1), 1);
  assert_eq!(to(1), 1);
}

let result: From = match_ty!(To, {
  u8 => from(1u8),
  u16 => from(2u16), // this would never called
  _ => unreachable!()
});

It would be better naming

• current match_type to match_cast
• and match_ty in this PR to match_type

But for non-breaking change, we naming it match_ty

[clouds56]

This would somehow also address #24 by implementing cast_from!

[clouds56]

Perform a compile-time style match over a single source type against one or more candidate destination types, executing the first matching branch.

This macro is the type-level analogue to [match_type!], but instead of matching on the runtime value of an expression it examines only the static type From (the first argument). Each arm lists one or more concrete destination types separated by |. If any of those destination types can be (symmetrically) cast to/from From (i.e. they are identical under this crate's rules), the corresponding branch expression is evaluated and its value becomes the macro's result.

Internally this uses [can_cast!] (fast path) and/or [get_cast_fns!] (when you request the function pointers) to test feasibility. Untaken branches compile away completely; there is no runtime overhead after monomorphization. No data transformation occurs: only identity casts for concretely equal types (respecting lifetime / lifetime‑free constraints) are considered matches.

Syntax

Basic form (boolean style matching on type only):

match_ty!(From, {
    Type1 => expr1,
    Type2 | Type3 => expr2,
    _ => default_expr,
})

A leading | before the first type in an arm (| Type1 | Type2 => ...) is also accepted for stylistic consistency with normal Rust pattern groups.

Function‑capturing form (obtain zero‑cost cast function pointers):

match_ty!(From, (from_fn, to_fn), {
    TargetType => expr_using_from_fn_and_to_fn,
    _ => fallback,
})

In a matching arm, from_fn has type fn(TargetType) -> From and to_fn has type fn(From) -> TargetType. In non‑matching arms those names are not bound (the code for that arm is never executed anyway). You may ignore one of them with _.

An entirely empty arm set is permitted: match_ty!(T, {}) expands to (). A final default arm (_ => ...) is otherwise required because you cannot enumerate all possible types.

Differences from [match_type!]

• Operates only on types; no value is evaluated or bound.
• Branch expressions cannot pattern‑match on a value of the matched type.
• Directly returns the branch expression (no intermediate Result).

Captured function pointer ordering

The tuple captured internally (and exposed via your (from_fn, to_fn) pattern) is (fn(Target) -> From, fn(From) -> Target). Naming them from and to is a common convention used in the examples below.

Examples

Basic categorization:

use castaway::match_ty;
fn classify<T: 'static>() -> &'static str {
    match_ty!(T, {
        u8 | i8 => "byte",
        u16 => "short",
        _ => "other",
    })
}
assert_eq!(classify::<u8>(), "byte");
assert_eq!(classify::<i8>(), "byte");
assert_eq!(classify::<u16>(), "short");
assert_eq!(classify::<u32>(), "other");

Specializing while capturing cast functions (note _ ignores the second):

use castaway::match_ty;
fn default_value<T: 'static + Default>() -> T {
    match_ty!(T, (from, _), {
        u8 => from(1u8),
        i32 => from(2i32),
        _ => T::default(),
    })
}
assert_eq!(default_value::<u8>(), 1);
assert_eq!(default_value::<i32>(), 2);
assert_eq!(default_value::<u16>(), 0); // via Default

Accessing both conversion directions directly:

use castaway::match_ty;
fn maybe_round_trip<T: 'static + Copy>() -> Option<(fn(u32)->T, fn(T)->u32)> {
    match_ty!(T, (from, to), {
        u32 => Some((from, to)),
        _ => None,
    })
}
assert!(maybe_round_trip::<u32>().is_some());
assert!(maybe_round_trip::<u16>().is_none());

Empty usage (rare):

use castaway::match_ty;
const _: () = match_ty!(u8, {}); // Expands to ()