This is a big topic and I can't give a simple answer but...
You can get a little closer to this answer by doing some divided and conquer,
and since the other answer tries to attack this problem from a hw point of view
I will try from a high level SW view.
If you write some software in let's say c code (a very high level of abstraction),
you do not really see what is happening not really understand all of the lover stuff that you are asking about.
But let's begin there anyway.
A simple program that just inc a variable.
Then we need to get the assembler code so we can understand what is going on.
This step can be done on what ever platform you use,
but to keep it simple I use gcc on a pc (but it does not matter...)
gcc -O0 -S main.c -o main.lst
Then we end up with something like this:
.type main, @function
movl %esp, %ebp
subl $16, %esp
movl $0, -4(%ebp)
addl $1, -4(%ebp)
.size main, .-main
.ident "GCC: (Ubuntu 4.4.3-4ubuntu5) 4.4.3"
Then you try to understand every line of code and what it does.
And then you start to look into how every instruction is implemented...
For example the subl
subl $16, %esp
At this point it is different on different architectures and x86, arm, pic is kind of different...
But since my example was x86.
And at this level when you read the copy most of actions will look like you are just moving numbers around, and in some sense this is what is happening.
We have a predefine program that we step trough, this program is store in a some kind of flash memory that is usually some kind of electronic logic that will trap one logic level.
If you see some kind of "Flip-flop" for every bit then you are kind of close, and then we needs a lot of those. Here we start to find your ones and zeros.
Then in order for some action to occur we add some cool logic that can transform one number into another number (the CPU it self).
And then we follow the program one step at a time, and to know where we are we have a program counter (PC). And move numbers back and fourth and storing those in another memory that is also kind of a grid with flip-flops.
But let's go back into some specific example again,
in order to understand the CPU a little better we can have a look at the ALU and this simplified picture.
Where you can see that when we move data into this logic block and do select some operation with the OP pins, we will get a new result at the output.
That we in turn can move back into some place in memory.
And of curse your ALU in your CPU part of your MCU is way more complex that this one, but it operates with the same basic principle.
At this point we kind of can see some logic circuit that does the "work" on one side, and some storage on the other side. And the storage has two parts, one for the program and one for the data.
But how does we actually "move" then, those must be connected in some way...
And this is where we connect those parts with some a bus.
A bus is just some wires that connects the different parts together, and then the control logic tells the memory what data to send onto this bus, and what part of the CPU that should listen to this data that was sent. And this is done with some parallel control lines that will enable/disable the different parts.
So if you take your mcu of choice and dissect a very small program,
and as long as you do not understand what is happening you dissect it even more until you have a nice little puzzle that can be used to create a "mcu".
And don't forget to read the datasheet for your mcu and look into what kind of parts it was made with, like what kind of memory, alu, busses etc etc.
Hope this helps a little ???