Does variable declaration mean memory allocation?

It depends on a lot of factor. The compiler can optimize and remove it from the stack, keeping the value in register. etc.

If you compile in debug it certainly does allocate some space in the stack but you never know. This is not specify. The only thing specify is the visibility of the variable and the size and arithmetic on it. Look at the C99 spec for more information.

from GNU:

3.2.1 Memory Allocation in C Programs

Automatic allocation happens when you declare an automatic variable, such as a function argument or a local variable. The space for an automatic variable is allocated when the compound statement containing the declaration is entered, and is freed when that compound statement is exited. In GNU C, the size of the automatic storage can be an expression that varies. In other C implementations, it must be a constant.

Nothing in the standard mandates that there is a stack. And nothing in the standard mandates that a local variable needs memory allocated for it. The variable could be placed in a register, or even removed altogether as an optimization.

There are no specification about that and your assumption is often (but not always) false. Consider some code like

void f() {
   int x;
   for (x=0; x<1000; x++) 
     { // do something with x 
     }
   // x is no more used here
}

First, an optimizing compiler would put x inside some register of the machine and not consume any stack location (unless e.g. you do something with the address &x like storing it in a global).

Also the compiler could unroll that loop, and remove x from the generated code. For example, many compilers would replace

for (x=0; x<5; x++) g(x);

with the equivalent of

g(0); g(1); g(2); g(3); g(4);

and perhaps replace

for (x=0; x<10000; x++) t[x]=x;

with something like

for (α = 0;  α < 10000;  α += 4) 
  { t[α] =  α; t[α+1] =  α+1; t[α+2] =  α+2; t[α+3] =  α+3; };

where α is a fresh variable (or perhaps x itself).

Also, there might be no stack. For C it is uncommon, but some other languages did not have any stack (see e.g. old A.Appel's book compiling with continuations).

BTW, if using GCC you could inspect its intermediate (Gimple) representations with e.g. the MELT probe (or using gcc -fdump-tree-all which produces hundreds of dump files!).