lint: Unnecessary intermediary conversion

What it does

This lints against using from twice using an itermediary type when there is an From implementation in one step

Advantage

• Reduce the verbosity of the code
• Make the intent clearer

Drawbacks

It might be possible that the 2 implementations do not have the same behaviour, but based on the documentation of From, this does not really fit the contract of the trait.

Example

With the context:

struct A;
struct B;
struct C;

impl From<B> for A {
    fn from(_: B) -> Self {
        Self
    }
}

impl From<C> for A {
    fn from(_: C) -> Self {
        Self
    }
}

impl From<C> for B {
    fn from(_: C) -> Self {
        Self
    }
}

let c: C = …;
let b: B = c.into();
let a: A = b.into();

Could be written as:

let c: C = …;
let a: A = c.into();

Start with the Rust examples in this issue and inspect existing Clippy lints for chained From or Into conversions to identify the relevant lint structure and test conventions. Done means the new lint reliably detects the shown two-step conversion when a direct From implementation exists, while avoiding cases outside that contract, with tests covering the behavior.