For free function kernels support clang forward declares the kernel
itself as well as its parameter types. In case a free function kernel has a
parameter that is templated and has a default template argument, all
template arguments including arguments that match default arguments must
be printed in kernel's forward declarations, for example

```
template <typename T, typename = int> struct Arg {
  T val;
};

// For the kernel
SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
    (ext::oneapi::experimental::nd_range_kernel<1>)) void foo(Arg<int> arg) {
  arg.val = 42;
}

// Integration header must contain
void foo(Arg<int, int> arg);
```

Unfortunately, even though integration header emission already has
extensive support for forward declarations priting,
some modifications to clang's type printing are still required.
infrastructure, since neither of existing PrintingPolicy flags help to
reach the correct result.
Using `SuppressDefaultTemplateArgs = true` doesn't help without printing
canonical types, printing canonical types for the case like
```
template <typename T>
SYCL_EXT_ONEAPI_FUNCTION_PROPERTY(
    (ext::oneapi::experimental::nd_range_kernel<1>)) void foo(Arg<T> arg) {
  arg.val = 42;
}
// Printing canonical types is causing the following integration header
template <typename T>
void foo(Arg<type-parameter-0-0, int> arg);
```

Using `SkipCanonicalizationOfTemplateTypeParms` field of printing policy
doesn't help here since at the one point where it is checked we take
canonical type of `Arg`, not its parameters and it will contain template
argument types in canonical type after that.