Python 3, 43 bytes

lambda s:re.sub("00|11","",s)[-1]
import re

Try it online!

The function takes a single string as input, where the first character is the initial state and the rest of the string represents the commands. This solution can be easily ported to other languages that have better support for regular expressions.

The difficult part is to prove the solution yields the correct outcome. To see this, we need a deep analysis of the commands. Firstly, we can see the commands have the following properties:

• 
  Property (1): commands 00 and 11 retain the accumulator state.


• 
  Property (2): commands 01 and 10 make the accumulator state the same as the second bit regardless of its original state.

Therefore, the final accumulator state is:

• 
  Case 1: If no 01 or 10 command exists, the final state is the same as the initial state.


• 
  Case 2: Otherwise, the last bit of the last 10 or 01 command.

Next we will show the solution yields the correct outcome in both cases. We will prove the statement for the final state 0 and the final state of 1 can be proved analogously. If the final state is 0 the input is in either of the following forms:

• 
  

  ^02k+111(11|00)*

  
  
  

  For Case 1, the input string s must start with 2k+1 0s, followed by 11 and 00 commands. Eliminating 00s and 11s yields a single 0, which is the final state.

  
  


• 
  

  .+102k+111(11|00)*

  
  
  

  For Case 2, the input string ends with a 10 command, followed by zero or more 00 and 11 s. This pattern is equivalent to a 1 followed by 2k+1 0s, and then zero or more 11s and 00s. Eliminating 00s and 11s leaves behind the last one of the 2k+1 0s at the end of the string, which represents the final state.

  
  

Based on all the above, after eliminating 00s and 11s simultaneously in one single pass (01001 is a counter-example if 00 is eliminated in one pass and then 11 in another pass) from the input s, the last character is the final state. Hence the correctness of the solution is proved.

Perl 6, 17 bytes

m/.)>[(.)$0]*$/

Try it online!

Takes advantage of "You can merge these two inputs into one input if you like" by taking input as the accumulator value concatenated with the commands e.g. 1,[00,11] is 10011. If this isn't okay, than it's only 5 extra bytes to take it as f(accumulator, commands). Returns a match object that can be coerced to a string.

Explanation:

 # Anonymous code block
 m/ / # Find the first match from the input
 .)> # Capture a number
 [ ]* # Followed by any number of
 (.)$0 # Pairs of identical characters
 $ # Ending the string

Basically this works because the 00 and 11 commands do literally nothing, while the 01 and 10 commands just set the accumulator to the second digit of the command. If there are no commands, then it takes the initial value of the accumulator instead.

Zsh, 33 bytes

The character list is passed as arguments, the initial value of the accumulator is passed as stdin.

read a
for x y;a=$[x^a?a:y]
<<<$a

Try it online!

39 bytes: If the commands must be a single string

Input is accumulator commands as arguments.

for x y ($(s::)2)1=$[x^$1?$1:y]
<<<$1

Try it online!

For fun, here's a 50 byte recursive one-liner (TIO):

<<<$$2+`f $[$1^$2[1]?$1:$2[2]] $2:2`:-$1

Python 3, 52 bytes

f=lambda a,s:s and f([s[1],a][s[0]==s[1]],s[2:])or a

Try it online!

Fixed inconsistent return type thanks to Chas Brown

Takes input as two strings; the accumulator and the code.

Brachylog, 11 9 bytes

tġ₂≠ˢtt|h

Try it online!

Since it's been long enough that I've been able to forget the notion of printing the accumulator after each command, I've formulated a significantly less naïve solution with some inspiration from Jo King's Perl answer.

 | The output is
 tt the last element of the last element of
t the last element of the input
 ġ₂ split into length-2 slices
 ≠ˢ with equal pairs removed.
 | If there is no such element, the input
 h 's first element is the output.

Old solution:

Brachylog, 18 16 bytes

ġ₂ᵗcth~h?ttˡ

Try it online!

-2 bytes from changing the input format.

JavaScript (ES6), 27 bytes

Takes input as (a)(code), where code is a is list of 2-bit integers.

a=>c=>c.map(x=>a^=x==a+1)|a

Try it online!

JavaScript (ES6),  47  40 bytes

Takes input as (a)(code), where code is a string.

a=>c=>c.replace(/../g,x=>a^=x%4==a+1)&&a

Try it online!

How?

All possible cases are summarized below. The only two cases where we need to toggle the accumulator are $(a=0,x=01_2)$ and $(a=1,x=10_2)$.

 a | x (bin) | int(x) % 4 | a + 1 | equal?
----+---------+------------+-------+--------
 0 | "00" | 0 % 4 = 0 | 1 | N
 1 | "00" | 0 % 4 = 0 | 2 | N
 0 | "01" | 1 % 4 = 1 | 1 | Y
 1 | "01" | 1 % 4 = 1 | 2 | N
 0 | "10" | 10 % 4 = 2 | 1 | N
 1 | "10" | 10 % 4 = 2 | 2 | Y
 0 | "11" | 11 % 4 = 3 | 1 | N
 1 | "11" | 11 % 4 = 3 | 2 | N

sed -E, 26 19 bytes

A whopping -7 bytes from @Cowsquack by realizing removing all pairs works as well.

s/(.)1//g
s/.*B//

Takes input concatenated together on stdin. Inspired by Jo King's Perl answer.
Strip trailing pairs Remove all pairs, then get last digit.

Try it online!
Try it online!

Retina 0.8.2, 18 11 bytes

(.)1

!`.$

Try it online! Link includes test cases. Takes input concatenated. Saved 6 bytes thanks to @CowsQuack for pointing out that removing all doubled characters and then taking the last remaining character works, although in fact the port of @JoKing's original answer could have been golfed by 3 bytes even without that trick.

Perl 5 -p, 37 33 bytes

$=<>;s/(.)(.)/$=$2if$==$1/ge}improve this answer