Handle the const struct * pattern.

Given that C keeps a different namespace for `struct`s and aliases. The
following pattern
```c
typedef const struct foo {
    void *bar;
} *foo;
```
is valid C code and produces both a `struct` and a pointer called `foo`.
Given that Rust does not make this distinction, we add the `_ptr` prefix
to the pointer type alias to avoid any name collisions.

Author: pvdrz

bindgen-tests/tests/expectations/tests/const_struct_ptr.rs

@@ -0,0 +1,6 @@
+typedef const struct foo {
+    char bar;
+} *foo;
+
+void takes_ptr(foo);
+void takes_struct(struct foo);

bindgen-tests/tests/headers/const_struct_ptr.h

@@ -1089,6 +1089,7 @@ impl Type {
                 }
                 CXType_Typedef => {
                     let inner = cursor.typedef_type().expect("Not valid Type?");
+                    let inner_spelling = inner.spelling();
                     let inner =
                         Item::from_ty_or_ref(inner, location, None, ctx);
                     if inner == potential_id {
@@ -1099,6 +1100,20 @@ impl Type {
                         // within the clang parsing.
                         TypeKind::Opaque
                     } else {
+                        // Check if this type definition is an alias to a pointer of a `const
+                        // struct` with the same name and add the `_ptr` suffix to it to avoid name
+                        // collisions.
+                        if !ctx.options().c_naming {
+                            if let Some(inner_name) = dbg!(inner_spelling
+                                .strip_prefix("const struct ")
+                                .and_then(|s| s.strip_suffix(" *")))
+                            {
+                                if inner_name == name {
+                                    name += "_ptr";
+                                }
+                            }
+                        }
+
                         TypeKind::Alias(inner)
                     }
                 }