Why does the inner function have to be assigned to a variable?

Who let the dogs out, who, who, who!

Just to supplement the info presented in the video, FreeCodeCamp has an excellent article on closures:
Let's Learn JavaScript Closures

Let's run dogHouse() in the console. What we get is as expected, it is the function showDogs, since this is declared in the return statement.

ƒ showDogs() {
    console.log(dogs); 
    console.log(birds);
  }

So we just saw that calling dogHouse() will give us the function showDogs(). Which logically leads to the conclusion that if we want to execute showDogs() all we need to do is assign dogHouse() to a variable and that variable will become the function that dogHouse() is returning to us. I know this might sound a bit weird, but if you really think about it logically it makes total sense.

var getDogs = dogHouse();  // getDogs "becomes" the function returned by the function call of 
// dogHouse(), which is the function showDogs();

Hey Leon Segal , that's not the necessary condition .
Yes , agreed Chavah Jacobs . You need to call the outer() within a variable to create a closure.
But it can be done through self invoking function too . I have explained that in my last example here.
First let's see , why we need to assign the inner function within a variable - When you call the outer function own its own , then no closure gets created. Also , most of the time "closure" is used the increment a counter variable to have track of it .
You can increment the counter only by calling the outer function within a variable and then calling that variable.
In this case , we are saving the returned function in a variable and then calling that returned function as many times as you want , the value get incremented every time.

var countBirds = function() {
  var count = 0; 
  return function(){
    count++;
    console.log(count + ' birds');
  }
};

var foo = countBirds();     // foo is now a closure

foo();     // 1 birds
foo();     // 2 birds
foo();     // 3 birds
foo();     // 4 birds
foo();     // 5 birds
foo();     // 6 birds

Here's is the example where we have call the outer function i,e countBirds function own its own and you can see , the counter doesn't get incremented because , when you are calling the function first time by writing countBirds() , it initializes a new variable , set it to 0 and then return the inner function . Be careful , counter has not been incremented yet. At this stage if you want to see the content of countBirds() , here we have --

console.log(countBirds());  //   ƒ (){ count++; console.log(count + ' birds');
  }

When you call it again by writing countBirds()() , it will run that returned function and will first increment the counter and the output the value 1.
The same phenomenon is happening in all the three steps where we have called the countBirds function - counter get reassigned to 0 , then increment to 1 and then logging out. We are not saving the returned function any where in this case .

var countBirds = function() {
  var count = 0; 
  return function(){
    count++;
    console.log(count + ' birds');
  }
};


countBirds()();     // 1 birds
countBirds()();     // 1 birds
countBirds()();     // 1 birds

Although , there is a way , if you don't want to use another variable and want to increment the counter just by calling the outer function i,e countBirds on its own , use **self invoking function A self-invoking expression is invoked (started) automatically, without being called.
Remember only Function expressions can be made "self-invoking" , not Function declaration.
Function expressions will execute automatically if the expression is followed by ().
You have to add parentheses around the function to indicate that it is a function expression. So let's try it:

var countBirds = (function() {
  var count = 0; 
  return function(){
    count++;
    console.log(count + ' birds');
  }
})();    

countBirds();     // 1 birds
countBirds();     // 2 birds
countBirds();     // 3 birds

So , it works :) . You can try either appraach whichever suits you . Happy Coding :)
Thank You

I think, based on the video and the MDN article on Closures, that a closure is in some ways a container. The container is created when the function is called within a specific Lexical Environment (which consists of the variable being called).

So if you call outer() within the variable of counter1, this is creating a closure (container) holding that specific value.

But if you called outer() on its own, without a lexical environment, then no closure (container) is created.

When you call outer() again, this is a totally new instance, and thus the counter starts at 0 again.

This is essentially what was said above by Jason Gresalfi.