Q:

How does a stack stores values in it?

I was watching the video What is stack and why do we need it? which is part of a course where the instructor shows us how to make a 16-bit VM in Javascript.
My question comes from the representation of stack in one of the frames of the video.
Let me quickly fill you all in on what's happening in this frame. On the left side of the image, we've all the registers:

ip: Instruction Pointer
acc: Accumulator
r1-r4: General Purpose Registers
sp: Stack Pointer

In the top right portion of the image, we have the instruction which is to be executed next. And below it is the current state of the stack.
Now, as you can see in the image, sp is currently pointing to the address $fffa and the corresponding value for it is $0000. Before this, the sp was pointing at the address $fffc and the instruction to be executed was psh r2. Similarly, before that, the sp was pointing at the address $fffe and instruction was psh r1.
Now, what I don't understand in this whole scenario is that addresses increase as we move down e.g. the address at the top is $ffe6 and the one below it is $ffe8 which is clearly greater than its predecessor, and the addresses keep on increasing. But why did our stack pointer sp started with the address $fffe in the first place? I know the stack works in FILO(First In Last Out)/LIFO(Last In First Out) fashion, and if we just ignore the sequence of the addresses, we'are following FILO/LIFO. But it's the sequence of addresses which confuses me. If we rotate our stack by 90 degrees anticlockwise, then our stack would look something like this.

Why I rotated the stack is to get the idea of how exactly memory addresses are laid out in any architecture.
Now, here I have these questions.

Why's the stack pointer starting from the last address in the stack?
Is this really how stacks are implemented in all languages?
Does this way of implementing stack help in averting problems that arise due to stack overflow?
Does it have anything to do with the way stack and heap are stored in the memory?
What would've changed if we started with the address $ffe6?

I may have asked many questions in a single post, but please give your most attention to the last question as I think it might answer all the other ones. Thank you.

A:

This question is dangerously close to both the too broad and primarily opinion based boundaries, but I can see what you are asking.
Understand that historically there have been countless different processor designs and system implementations.  Languages as well as processors have evolved over time.  So any absolute statements are in fact, limited as there has no doubt been a system or processor to which that statement does not apply.
In general the stack is just memory and the stack pointer is just an address/offset in that memory, how a push/pop differs from a normal memory access is the programmer doesn't/shouldn't usually care about the specific address, but instead relative, I pushed five things so the third thing is this far away from the stack pointer, to clean up I need to pop 5 things, etc.  But its just a ram somewhere with an address pointer.
While we think of lower numbered addresses as being lower and higher numbered addresses being higher, and expect drawings/visualizations of memory having the lowered numbered addresses lower on the diagram and higher addresses higher on the diagram there are times for a good reason or sometimes not this is flipped.  On a chip there isn't an up or down really and there isn't an assumption that the memory is laid out in some long physically linear 2D fashion, these are all simply visualizations.
I don't know of an exception but generally processors execute in the direction of increasing addresses, an instruction at address 0x1000 that is 4 bytes in length, the next instruction is assumed to be at 0x1004, not at 0xFFC.  So let's assume that code grows upward or from lower addresses to higher addresses.
Let's assume that our firmware runs in ram and not flash, and we are talking about consumption of ram.  And think in terms of baremetal not an operating system with many applications loaded at once.
A program generally will have some code (often called .text), some data, (global) variables, etc. (often called .data and .bss).  Heap which is run time allocated memory and stack.
I have not researched this but based on what I was taught and the name itself, one could think of stack as a stack of plates or a stack of note cards.  which due to gravity grow upward.  And independent of the processor architecture, it is not uncommon to visualize a stack as growing upward, new items are placed on top of older items, removing the top item to get at lower items.  But this is not so rigid, not sure if it is 50/50 but you will as often see it visualized as growing down as well as up.  or a sliding window with the stack pointer not moving visually in the diagrams but the data moving up or down depending on how shown.
Also note, the name of this site, Stack Overflow, that term has a particular assumption of what that means...
So cut to the chase, the classic model (which has exceptions mentioned later), is that starting at lower memory or let's even assume zero, you have your code, the machine code and whatever else that falls into that category.  then you have your global variables .data and .bss, then you have your heap and the topmost is your stack.  Heap and stack are considered dynamic at runtime.  If you never free then heap is assumed to grow upward.  So the natural solution for stack is for it to then grow downward.  You start your heap at the lowest address you can ideally on top of the other items (.text, .data, .bss) and the stack as high as you can, so that a stack overflow (stack and heap colliding, the stack growing into heap allocated ram).
This traditional model implies that the stack grows downward meaning from higher addresses to lower addresses.  Many instruction set architectures limit the push/pop solutions to that, using the instructions as designed the stack grows downward there are exceptions for example the traditional (pre-aarch64) arm instructions (full sized not thumb) can go either way, so in that case it is the compiler authors choice and not forced by the architecture.  Arguably with a general purpose register that can access memory a compiler can choose to use simple load/store instructions and not push/pop or equivalent instructions and do whatever they want.  But with possibly very limited exceptions, the stack grows downward from an address perspective.
Some architectures the stack is buried in non-visible space, old old chips may have relative to today a very small stack like 16 deep or 32 and our only access is push and pop and that's it.
Some architectures with a push/pop or equivalent, on a push for example will write then adjust the stack pointer or adjust the stack pointer then write so for a 16 bit system to get all the locations you can you would start with 0x10000 which you cant represent so 0x0000, others 0xffff or 0xfffc depending on the architecture and how it works, etc.
So if you want to visualize a stack as literally a stack of things a stack of note cards a stack of plates, etc.  Then due to gravity you would visualize it as growing upward.  I write a number on a note card place it on the stack write another number on a note card and place (push) it on the stack, remove the card (pop) and so on.  So since it is a 50/50 thing you will sometimes see the stack visualized this way with higher addresses on the lower part of the diagram and lower addresses on the upper part of the diagram.
So opinion based, this is why they drew the diagram that way.  At the end of the day be prepared mentally to deal with whichever way folks visualize a stack.

Why's the stack pointer starting from the last address in the stack?

This is typical in a classic sense.  Real world stuff though, there are use cases where the stack is placed in a different memory space than other items possibly protected from going out of its space by the security features (mmu, etc).  But it is often an architecture limitation that the normal use of the stack pointer and/or instructions is for the stack to grow downward with respect to the memory address used.  so if you grow down you want to start high.  Last address is a textbook way to do it, but often you will see folks allocating stack space in the linker script and it lands where it lands (sometimes even below heap or data).

Is this really how stacks are implemented in all languages?

Too broad, the language itself compiles to code that uses instructions, its linking and the bootstrap (or the operating system) that determines the initial value for the stack for a program.  And not uncommon for the stack pointer based instructions to be limited to a downward growing stack. If there is a choice, opinion based, I would expect due to history the implementation would be downward (address) growing.

Does this way of implementing stack help in averting problems that arise due to stack overflow?

Yes if we assume the heap grows upward and the stack grows downward then you want the heap to start at the bottom of the available space and the stack at the top to give the most room before a stack overflow happens.

Does it have anything to do with the way stack and heap are stored in the memory?

Yes, opinion based.  As covered above.

What would've changed if we started with the address $ffe6?

Nothing really as each "function" is called the stack pointer is where it is, that's the whole point you don't care about the address just care about matching the pushing and popping or where possible relative addressing, not absolute.  So if $ffe6 then as you push and pop the address gets smaller/larger.  If $8000, same deal $5432, same deal.  If you started at a different address than shown in the tutorial everything works the same, just the physical addresses shown would need to reflect the new starting point.

So yes the traditional/textbook view of a stack is last in first out.  Growing downward in address space, but 50/50 as to how the author of a text visualizes this with high address on the bottom of the diagram or on the top.  Realistically, higher performing instruction sets are not limited to strictly pushing and popping but also relative addressing so while you start by learning just push/pop you then go right into relative addressing.   I pushed 5 things on the stack I can access all of them with sp+offset addressing, sometimes with special sp based instructions.
Don't get worked up about how some tutorial/textbook author visualized the stack, higher addresses on top or bottom.

