Add support for transparent typedefs

[scovich]

Following #967, introduce /// cbindgen:transparent-typedef annotation that causes cbindgen to replace transparent structs and typedefs with their underlying type.

This allows the following:

/// cbindgen:transparent-typedef
#[repr(transparent)]
struct Foo(NonNull<i32>);

/// cbindgen:transparent-typedef
type Function = extern "C" fn(i: i32) -> i64;

type NullableFoo = Option<Foo>;
type NullableFunction = Option<Function>;

to export as

typedef i32 *NullableFoo;
typedef int64_t (*NullableFunction)(int32_t);

instead of today's output:

template<typename T = void>
struct Option;

using Foo = int32_t*;
using Function = int64_t(*)(int32_t i);

using NullableFoo = Option<Foo>;
using NullableFunction = Option<Function>;

[emilio]

Need to take a closer look but over all looks reasonable.

[emilio]

These changes seem unrelated? Seems ok, but maybe worth splitting into its own commit / PR? Or is it some sort of autoformatting i'm not aware of?

[scovich]

I was just fixing broken indentation in the existing .md, so that bullets would render correctly. If you hide whitespace changes the diff disappears:

Happy to split it out if it's too noisy/annoying, tho.

[emilio]

I think it'd be a bit clearer to do it the other way around. In fact, wouldn't it be a bit nicer to just:

let mut erased_any = false;
macro_rules! try_erase {
    ($item:tt) => {
        if let Some(erased) = eraser.erase_transparent_types(library, $item, mappings) {
            erased
        } else {
            $item.clone()
        }
    }

Then:

let ret = try_erase!(ret);
...

if erased_any {
    return Some(..);
}

[scovich]

Ah, nice suggestion. I implemented it with a lambda instead of a macro tho.

[scovich]

I just noticed that this PR overlaps significantly with #699, and probably fixes both #690 (NonZero) and #326 (Option)?