A funny thing about circuits: they work nothing like what we software developers expect them to. Specifically, it turns out that synchronous circuits, like memory, registers, counters etc. can only do one thing in one clock cycle. This means for example that you can't read the instruction and the subsequent immediate value in the same clock cycle. You have to split your work across multiple clock cycles.

In our simplified example, ROM is an asynchronous circuit, so we could read multiple values  In real life RAM takes many cycles to get the value from, and the faster the processor, the more cycles it need to wait for RAM.

Let's try to imagine how such logic could look like:

    module CPU(input iClk, input iRst, output [7:0] oAddressBus, input [7:0] iMemoryValue);

    localparam MVI=2'b00, MOV=2'b01, ALU=2'b10, ALI=2'b11;

    localparam B = 3'b000, C = 3'b001, D = 3'b010, E = 3'b011, 
               H = 3'b100, L = 3'b101, M = 3'b110, A = 3'b111;

    reg [7:0] _pc;

    //Now that we realized we need to do things across multiple clock cycles,
    //we'll need a register to keep track of where we are.
    reg _mode;
    localparam
        NORMAL=1'b0, // reading the instruction
        READ_IMMED=1'b1; // reading the data value immediately following the instruction

    //also, need a register to remember the instruction once the memory has advanced to the next cell.
    reg [7:0] _instruction;

    always @(posedge iClk, posedge iRst)
    begin
        if(iRst)
            begin
                $display("resetting...");
                _pc = 8'h0;
                //always start in the Normal mode
                _mode = NORMAL;
            end
        else begin
            $display("PC:%d", _pc);
            $display("mem:%d", iMemoryValue);

            //do a different thing depending on the current mode
            case(_mode)
                NORMAL:
                    if(iMemoryValue == 8'h0) $display("executing NOP!");
                    else case(iMemoryValue[7:6])
                        MVI: if(iMemoryValue[2:0] == M) begin
                                $display("initiating MVI");
                                //switch the mode so we can read the next memory value on the next clock cycle.
                                _mode = READ_IMMED;
                                //remember this is an MVI we're processing.
                                _instruction = iMemoryValue;
                             end
                             else $display("unknown instruction");
                        default:
                            $display("unknown instruction");
                    endcase
                READ_IMMED: begin
                    //we know we're in the middle of an MVI instruction.
                    //now we can read the second operand from memory and execute the instruction.
                    case(_instruction[5:3])
                        B: $display("MVI B, %d", iMemoryValue);
                        C: $display("MVI C, %d", iMemoryValue);
                        D: $display("MVI D, %d", iMemoryValue);
                        E: $display("MVI E, %d", iMemoryValue);
                        H: $display("MVI H, %d", iMemoryValue);
                        L: $display("MVI L, %d", iMemoryValue);
                        M: $display("MVI M, %d", iMemoryValue);
                        A: $display("MVI A, %d", iMemoryValue);
                    endcase
                    //don't forget to switch back to the normal mode.
                    _mode = NORMAL;
                end
            endcase

            _pc = _pc + 1'b1;
        end
    end

    assign oAddressBus = _pc;

endmodule  

And the print out is:

--------------Tick           1---------------
PC:  x  
mem:  x  
--------------Tick           2---------------
PC:  x  
mem:  x  
--------------Tick           3---------------
PC:  x  
mem:  x  
resetting...  
--------------Tick           4---------------
PC:  0  
mem:  0  
executing NOP!  
--------------Tick           5---------------
PC:  1  
mem:  6  
initiating MVI  
--------------Tick           6---------------
PC:  2  
mem: 55  
MVI B,  55  
--------------Tick           7---------------
PC:  3  
mem: 14  
initiating MVI  
--------------Tick           8---------------
PC:  4  
mem:255  
MVI C, 255  
--------------Tick           9---------------
PC:  5  
mem:  1  
unknown instruction  
--------------Tick          10---------------
PC:  6  
mem:  x  
unknown instruction  
--------------Tick          11---------------
PC:  7  
mem:  x  
unknown instruction  
--------------Tick          12---------------
PC:  8  
mem:  x  
unknown instruction  
--------------Tick          13---------------
PC:  9  
mem:  x  
unknown instruction  

See how on tick 5 we're "initiating MVI" and on tick 6 we have a complete instruction, including the immediate value? I wonder what it would take to actually execute an instruction...