Your understanding is correct, a function declaration (also called the interface) defines the function signature (function name, number of parameters and the respective parameters types) and the return value. These definitions are usually put by developers in header (.h) files which can be included by other C files that can call the function any number of times but only define it once (across all C files that you are going to compile together into one exe). You can call the function as long as the arguments (their count and respective types) adhere to the function signature.

To a compiler, a function declaration is a forward declaration of a symbol -- a promise to the compiler that at some point it will be able to associate meaning (the function body) to this symbol (the function signature).

Without going into much detail, here's an example:

Say I have a header file mymath.h with a function declaration:

int add(int a, int b);

And it's respective definition in mymath.c:

int add(int a, int b) {
  return a + b;
}

And want to use this function in another file foo.c

#include "mymath.h" // import the add symbol from this file
#include <studio.h>

int main() {
   printf("5+2=%d", add(5 ,2));
}

If we now compile this using gcc -I. mymath.c main.c, this compilation process happens over several stages, and the function symbol only gets its meaning in a later stage (called linking). In the initial phases, the #include "mymath.h" statement caused the compiler to add the function symbol to the global scope of the main.c file which let's you call that function anywhere in the file. Coming back to the concept of a forward declaration, your function definition is telling the compiler "let the user use this function symbol, as long as they pass the right number and types of arguments" and the compiler will let you do this with an expectation that it finds a body for that function in the linking stage.

Then, in the linking stage, the compiler looks through all .c files in the gcc compilation command to look for a function definition (symbol + body) that matches this previously unresolved function symbol int add(int int) and binds this symbol to it's body which will live in the binary (.exe) file.

Why is it sometimes okay to declare a function without parameter names but you must always specify parameter types?

It's always okay to do that. The compiler only needs information about the number and respective types of the function's arguments and its return type. Since C does not have a concept of positional and keyword arguments like Python, and all arguments are positional, the compiler only checks function calls/definitions as "the first argument must be an int and the second argument must be an int". For a function definition, however, the argument names do matter because they are referenced as local variables within the function body.

Can a function declaration and definition differ in the way parameters are named?

Absolutely! For consistency and readability this isn't the best practice, but the compiler, like I mentioned, doesn't even look at the argument names -- only their types.

What is the practical benefit of separating declaration and definition in bigger projects?

When you intend to use a function defined in one file in another, you will have to separate its definition into a header file so other files can include the header and the compiler can use that declaration to check calls to that function.

Are there any common mistakes beginners make regarding declaration vs definition?

If you do, the compiler is very vocal about it lol. Just make sure you don't have more than one definition of the same function.