Remove From implementations from the direction types

[tim-blackbird]

This removes the From<Vec2/3> implementations for the direction types.
It doesn't seem right to have when it only works if the vector is nonzero and finite and produces NaN otherwise.

Added Direction2d/3d::new which uses Vec2/3::try_normalize to guarantee it returns either a valid direction or None.

This should make it impossible to create an invalid direction, which I think was the intention with these types.

[Jondolf]

My main concern with this is that it potentially makes a lot of APIs needlessly awkward. For example, creating a Segment2d:

// Before
let segment = Segment2d::new(Vec2::X.into(), 2.0); // .into() could even be removed with impl Into<Direction2d>

// After
let segment = Segment2d::new(Direction2d::new(Vec2::X).unwrap(), 2.0);

For rays, I was considering an API where Ray2d::new takes an impl Into<Direction2d> so that you could either just pass a vector that would automatically be normalized, or directly pass a Direction2d to avoid the extra normalization. This isn't possible if Direction2d doesn't implement From<Vec2>, so it would either have to always normalize the given vector or take a Direction2d which is bad for DX.

I do see value in requiring the direction to always be valid, but NaN or non-finite values for directions should be rare enough that I'm hesitant to take the DX hit for it. I believe the main goal of Direction2d/Direction3d is to make sure normalize is always called (but as few times as possible) for all direction vectors. It doesn't necessarily give guarantees about degenerate cases like NaN.

[alice-i-cecile]

I think that the correctness is more important here. There's no guaranteed one-to-one mapping between a Vec2 and a direction unfortunately.

I'd be fine with a TryFrom impl instead or in addition to this though.

[alice-i-cecile]

@Jondolf, I definitely see your point, but IMO we should instead add explicitly infallible (panicking) constructors.

[Jondolf]

After thinking about this more, I think I'm also leaning in favor of this change now. It does make some things a bit more verbose, but the correctness and explicitness is perhaps more important, and if desired, primitives could still have panicking constructors that handle the vector to direction conversion in the background.

I think having an additional TryFrom impl would make sense because that's basically what new does, but try_from/try_into might be less common and accessible for users so I'd still preserve new.