Introduce forward.h header with forward declarations

In preparation for adopting forward declarations to reduce unnecessary
transitive includes across the tree, let's introduce a forward.h header
with forward declarations for all libc, libsystemd, basic and shared types.

Additionally, this header exports all basic integer types and errno constants,
as well as all macros including assertions macros. These header files contain
types often used in headers and are always included in every source file one
way or another anyway.

To avoid having to include memory-util.h and alloc-util.h in forward.h, we
split off the parts we need from both into cleanup-util.h and only include
cleanup-util.h in forward.h.

To keep this commit self-contained, we include cleanup-fundamental.h and
cleanup-util.h from the headers that originally contained the same macros.
We'll remove these again in a later commit that optimizes the includes in
src/basic and src/fundamental.

Split out of #37364

src/basic/alloc-util.h

@@ -7,6 +7,7 @@
 #include <string.h>
 
 #include "assert-util.h"
+#include "cleanup-util.h"
 #include "macro.h"
 #include "memory-util.h"
 
@@ -14,9 +15,6 @@
 #  include <sanitizer/msan_interface.h>
 #endif
 
-typedef void (*free_func_t)(void *p);
-typedef void* (*mfree_func_t)(void *p);
-
 /* If for some reason more than 4M are allocated on the stack, let's abort immediately. It's better than
  * proceeding and smashing the stack limits. Note that by default RLIMIT_STACK is 8M on Linux. */
 #define ALLOCA_MAX (4U*1024U*1024U)
@@ -52,30 +50,9 @@ typedef void* (*mfree_func_t)(void *p);
 
 #define malloc0(n) (calloc(1, (n) ?: 1))
 
-#define free_and_replace_full(a, b, free_func)  \
-        ({                                      \
-                typeof(a)* _a = &(a);           \
-                typeof(b)* _b = &(b);           \
-                free_func(*_a);                 \
-                *_a = *_b;                      \
-                *_b = NULL;                     \
-                0;                              \
-        })
-
 #define free_and_replace(a, b)                  \
         free_and_replace_full(a, b, free)
 
-/* This is similar to free_and_replace_full(), but NULL is not assigned to 'b', and its reference counter is
- * increased. */
-#define unref_and_replace_full(a, b, ref_func, unref_func)      \
-        ({                                       \
-                typeof(a)* _a = &(a);            \
-                typeof(b) _b = ref_func(b);      \
-                unref_func(*_a);                 \
-                *_a = _b;                        \
-                0;                               \
-        })
-
 void* memdup(const void *p, size_t l) _alloc_(2);
 void* memdup_suffix0(const void *p, size_t l); /* We can't use _alloc_() here, since we return a buffer one byte larger than the specified size */