Add support for non-COM interfaces

[kennykerr]

Well, this was a lot more complicated than I'd hoped! I'm not a big fan of interfaces that sort of pretend to be COM interfaces but don't actually inherit from IUnknown. The thing is that IUnknown addresses a number of fundamental problems with lifetime and discovery that are just left in question without it. The solution here isn't perfect but it's a start and builds on a number of PRs that have already been completed. Here's what's new:

1. You can use the interface macro to declare a (new) interface that derives from an existing interface defined by the windows crate. The implement macro can implement COM interfaces regardless of how they were declared.

2. You cannot implement non-COM interfaces with the implement macro. Since IUnknown is not available to reason about lifetime, the implement macro isn't much use, but you can simply use the new method on the interface to "wrap" an implementation of the interface's trait (or traits) with a scoped implementation.

struct Reflection;

impl ID3D12FunctionParameterReflection_Impl for Reflection {
    fn GetDesc(&self) -> Result<D3D12_PARAMETER_DESC> {
        todo!();
    }
}

let reflection = ID3D12FunctionParameterReflection::new(&Reflection);
let desc = reflection.GetDesc()?;

3. You can use the interface macro to declare a (new) interface that does not derive from IUnknown. This too can be implemented in the same way:

#[interface]
unsafe trait IValuable {
    unsafe fn Value(&self) -> i32;
}

struct Valuable(i32);

impl IValuable_Impl for Valuable {
    unsafe fn Value(&self) -> i32 {
        self.0
    }
}

unsafe fn call_value(test: &IValuable) -> i32 {
    test.Value()
}

#[test]
fn main {
    unsafe {
        // Since the interface is not rooted in `IUnknown`, there's no COM-style lifetime and the 
        // resulting implementation merely exists for the lifetime of the referenced implementation. 
        let test = Valuable(456);
        let interface = IValuable::new(&test);
        assert_eq!(call_value(&interface), 456);
        assert_eq!(interface.Value(), 456);
    }
}

4. Non-COM interfaces no longer hold a private IUnknown pointer so you don't have to worry about them doing bad things when dropped.

Fixes: #453

[wesleywiser]

Thanks @kennykerr! Really appreciate your help on this 🥇