Working record finalizer

[diamondburned]

Right now, record finalizers are implemented incorrectly. An example code from ./pkg/gsk/v4/gsktypes.go shows this issue:

	_cret = C.gsk_transform_rotate_3d(_arg0, _arg1, _arg2)

	var _transform *Transform // out

	_transform = (*Transform)(unsafe.Pointer(_cret))
	C.gsk_transform_ref(_cret)
	runtime.SetFinalizer(_transform, func(v *Transform) {
		C.gsk_transform_unref((*C.GskTransform)(unsafe.Pointer(v)))
	})

Here, the C-heap-allocated (malloced) _cret pointer is converted into a pointer to a Go type, and a finalizer is set on the converted value. This doesn't work, however. Running this code will trigger a runtime panic:

fatal error: runtime.SetFinalizer: pointer not in allocated block

It seems like the most straightforward solution would be to forbid Go from allocating record types at all by generating all records like so:

type Transform struct {
    nocopy [0]sync.Mutex
	native *C.GskTransform
}

This way, zero-values of Transform are always invalid, and the caller must use an appropriate constructor that mallocs the value. The nocopy field ensures that the struct value is never copied, because copying the struct value will ruin the finalizer. The alignment of that field means that nocopy does not grow the Transform type to be more than a pointer.

It might also be worth it to consider making native a uintptr type instead of an actual pointer type to reduce possible GC overhead, but this is likely already handled trivially in the Go runtime.

[diamondburned]

An external package could cast the type without needing to access the unexported fields by unsafe casting the types, like how the code generator currently handles unexported fields from some cairo types:

	{
		_p := &struct{ p unsafe.Pointer }{unsafe.Pointer(_cret)}
		_pattern = (*cairo.Pattern)(unsafe.Pointer(_p))
	}
	C.cairo_pattern_reference(_cret)
	runtime.SetFinalizer(_pattern, func(v *cairo.Pattern) {
		C.cairo_pattern_destroy((*C.cairo_pattern_t)(unsafe.Pointer(v.Native())))
	})

Only now, it would look something like this:

	p := &struct {
		_ [0]sync.Mutex
		p unsafe.Pointer
	}{
		[0]sync.Mutex{},
		unsafe.Pointer(new(string)),
	}

It would probably be tedious to inline something like that, but it's probably better than generating helper functions.