Haskell, 47 bytes

e#(a:b)|e==a=2*a:b|1<2=e:a:b
e#_=[e]
foldr(#)[]

Uses reduce (or fold as it is called in Haskell). Usage example: foldr(#)[] [2,2,2,4,4,8] -> [2,4,8,8].

Jelly, 10 9 8 bytes

Œg+2/€UF

TryItOnline or run all test cases

How?

Œg+2/€UF - Main link: a                 e.g. [2,2,2,4,4,8]
Œg       - group runs of equal elements      [[2,2,2],[4,4],[8]]
   2/€   - pairwise reduce for each with
  +      -     addition                      [[4,2],[8],[8]]
      U  - reverse (vectorises)              [[2,4],[8],[8]]
       F - flatten list                      [2,4,8,8]

Brain-Flak 158

([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}{(({}<>)<><(({})<<>({}<>)>)>)({}[{}]<(())>){((<{}{}>))}{}{{}(<({}{})>)}{}({}<>)<>}<>

Try it online!

Explanation:

1 Reverse the list (taken from the wiki)

([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}

2 Do steps 3-6 until there is nothing left on this stack:

{                                                                                         }

3 Duplicate the top two elements (2 3 -> 2 3 2 3)

(({}<>)<><(({})<<>({}<>)>)>)

(({}<>)<>                   #put the top number on the other stack and back on the very top
         <(({})             #put the next number on top after:
               <<>({}<>)>   #copying the original top number back to the first stack
                         )>)

4 Put a 1 on top if the top two are equal, a 0 otherwise (from the wiki)

({}[{}]<(())>){((<{}{}>))}{}

5 If the top two were equal (non-zero on the top) add the next two and push the result

{{}(<({}{})>)}{}
{            }   #skip this if there is a 0 on top
 {}              #pop the 1
   (<      >)    #push a 0 after:
     ({}{})      #pop 2 numbers, add them together and push them back on 
              {} #pop off the 0

6 Move the top element to the other stack

({}<>)<>

7 Switch to the other stack and print implicitly

<>

PHP, 124 Bytes

<?$c=count($a=$_GET[a]);while($c){if($a[--$c]==$a[$c-1]){$r[]=2*$a[$c];$c--;}else$r[]=$a[$c];}sort($r);echo json_encode($r);

Perl, 47 + 1 (-p) = 48 bytes

Edit : added \b, as without it it was failing on input like 24 4 on which the output would have been 28.

$_=reverse reverse($_)=~s/(\b\d+) \1\b/$1*2/rge

Run with -p flag :

perl -pe '$_=reverse reverse($_)=~s/(\d+) \1/$1*2/rge' <<< "2 2 2 4 4"

I don't see another way than using reverse twice to right-fold (as just s/(\d+) \1/$1*2/ge would left-fold, i.e 2 2 2 would become 4 2 instead of 2 4). So 14 bytes lost thanks to reverse... Still I think there must be another (better) way (it's perl after all!), let me know if you find it!

Retina, 32

\d+
$*
r`\b\1 (1+)\b
$1$1
1+
$.&

r on line 3 activates right-to-left regex matching. And this means that the \1 reference needs to come before the (1+) capturing group that it references.

Try it online.

GNU sed 41 38

Includes +1 for -r
-3 Thanks to Digital Trauma

:
s,(.*)(1+) \2\b,\1!\2\2!,
t
s,!, ,g

Input and output are space separated strings in unary (based on this consensus).

Try it online!

05AB1E, 26 bytes

D¥__X¸«DgL*ê¥X¸«£vy2ôO})í˜

Try it online!

Generalized steps

1. Reduce by subtraction to find where consecutive elements differ
2. Reduce by subtraction over the indices of those places to find the length of consecutive elements
3. Split input into chunks of those lengths
4. Split chunks into pairs
5. Sum each pair
6. Reverse each summed chunk
7. Flatten to 1-dimensional list

JavaScript (ES6), 68 65 58 57 bytes

Waiting for the OP answers to fix it if necessary for cases such as [2N, N, N].

f=(a,l=[])=>(x=a.pop())-l?f(a,x).concat(l):x?f(a,2*x):[l]

console.log(f([2, 2, 4, 4]));
console.log(f([2, 2, 2, 4, 4, 8]));
console.log(f([2, 2, 2, 2]));

Alternate version, 72 bytes

More bullet-proof:

a=>a.reverse().join`+`.replace(/(.)\+\1/g,c=>eval(c)).split`+`.reverse()

Python 2, 94 bytes

def f(a,r=[]):
 while a:
    if len(a)>1and a[-1]==a[-2]:a.pop();a[-1]*=2
    r=[a.pop()]+r
 print r

Try it online