Python 3, 128 bytes

def t(z):j=z and(z[0]==z[1:2])+1;return[str(int(z[0])*j),*t(z[j:])]if j else''

def c(n):r="".join(t(n));return r!=n and c(r)or r

Try it online!

Python 2, 97 96 93 bytes

def f(n):r=re.sub(r'(.)1',lambda m:`int(m.group(1))*2`,n);return r!=n and f(r)or r

import re

Try it online!

Non regex version:

Python 2, 133 130 122 112 98 bytes

def f(n):

 r='';s=n

 while s:a=1+(s[0]==s[1:2]);r+=`int(s[0])*a`;s=s[a:]

 return r!=n and f(r)or r

Try it online!

Jelly, 11 bytes

DŒg+2/€FVµ¡

This is an unnecessarily slow, full program.

Try it online!

Alternate version, 12 bytes

DŒg+2/€FVµƬṪ

One byte longer, but much faster. Works as a program or a function.

Try it online!

How it works

DŒg+2/€FVµƬṪ  Main link. Argument: n (integer)



         µ    Combine the previous links into a chain. Begin a new one.

D               Decimal; yield n's digit array in base 10.

 Œg             Group adjacent, identical digits into subarrays.

   +2/€         Map non-overlapping, pairwise sum over the subarrays.

                If there is an odd number of digits in a subarray, the

                last digit will remain untouched.

       F        Flatten; dump all sums and digits into a single array.

        V       Eval; turn the result into an integer.

          Ƭ   Execute the chain 'til the results are no longer unique.

              Return all unique results.

           Ṫ  Tail; extract the last result.

The 11-byte version does the same, except it calls the link n times for input n, instead of calling it until a fixed point is reached.

Haskell, 70 bytes

until((==)=<<f)f

f(a:b:c)|a==b=show(2*read[a])++f c|1<2=a:f(b:c)

f a=a

Input is taken as a string.

Try it online!

JavaScript, 48 47 bytes

Input and output as strings. Returns the nth term of the sequence.

f=s=>s-(s=s.replace(/(.)1/g,x=>x[0]*2))?f(s):s

Try it online

1 byte saved thanks to Arnauld

Perl 6, 37 bytes

{($_,{S:g[(d)$0]=2*$0}...*==*)[*-1]}

Try it online!

This is a function which generates the nth term of the sequence, given n as its argument.

($_, { ... } ... * == *) is the sequence of successive changes to the input number, generated by the bracketed expression (a simple regex substitution) and stopping when * == *, that is, when the last two numbers in the sequence are equal. Then the [*-1] takes just the final element of that sequence as the return value.

C# (.NET Core), 231, 203, 200, 196 bytes

EDIT: Function is now at 185 bytes plus 18 for using System.Linq;

Thanks to BMO (for 1>0 being equal to true plus newline removal) and Mr. XCoder (for f=!f statements)!

EDIT2: Down to 182 bytes plus 18 for using System.Linq thanks to dana for sharing a few golf tips!

EDIT3: Thanks to Embodiment of Ignorance for the int -> var, removal of short circuit && -> &, and changing up ToArray -> ToList! (178 bytes + 18 using)

p=>{var f=1>0;while(f){var t=p.Select(n=>n-48).ToList();p="";f=!f;var h=t.Count;for(var j=0;j<h;j++){if(j<h-1&t[j]==t[1+j]){p+=t[j]+t[1+j++];f=!f;continue;}p+=t[j];}};return p;};

Try it online!

Retina, 16 bytes

+`(.)1

$.(2*$1*

Try it online! Link includes test cases. Explanation:

+`

Repeat until the input stops changing.

(.)1

Replace pairs of adjacent digits...

$.(2*$1*

... with twice the digit. ($1* generates a string of $1 _s, 2* duplicates that, and $.( takes the length. Actually, the Retina engine is cleverer than that and just doubles $1.)

Perl 5 -p, 21 bytes

s/(.)1/$1*2/ge&&redo

Try it online!

C# (Visual C# Interactive Compiler), 112+33 bytes

/u:System.Text.RegularExpressions  

string x(string p)=>Regex.IsMatch(p,@"(d)1")?x(Regex.Replace(p,@"(d)1",m=>((m.Groups[0]+"")[0]-48)*2+"")):p;

Try it online!

Regex/Recursion-based solution. Thanks to @dana for -11 bytes

using System.Text.RegularExpressions;

//Recursive statement taking a string as parameter

string x(string p)=>

//Does the number have any pairs?

Regex.IsMatch(p,@"(d)1")?

//If yes, then call this method again with this new string

x(

//Find every pair in the string

Regex.Replace(p,@"(d)1",

//And replace them with the pair's sum

m=>((m.Groups[0]+"")[0]-48)*2+""))

//Else just return the string as is

:p;

Groovy, 63 bytes

{s->r=/(d)1/

while(s=~r)s=s.replaceAll(r){(it[1]as int)*2}

s}

Try it online!

05AB1E, 11 bytes

Δγε2ôSO}˜J

Try it online or verify all test cases.

Explanation:

Δ             # Continue until the (implicit) input no longer changes:

 γ            #  Split the integer in chunks of the same adjacent digits

              #   i.e. 199999889 → [1,99999,88,9]

  ε     }     #  Map each to:

   2ô         #   Split it into parts of size 2

              #    i.e. 99999 → [99,99,9]

     €S       #   Split each part into digits

              #    i.e. [99,99,9] → [[9,9],[9,9],[9]]

       O      #   And take the sum of each part

              #    i.e. [[9,9],[9,9],[9]] → [18,18,9]

         ˜    #  Flatten the list

              #   i.e. [[1],[18,18,9],[16],[9]] → [1,18,18,9,16,9]

          J   #  Join everything together

              #   i.e. [1,18,18,9,16,9] → 118189169

              # (And output the result implicitly at the end)

              #  i.e. output = 28189169

Japt v2.0a0 -h, 15 14 bytes

Returns the nth term of the sequence.

Æ=s_r/(.)1/ÏÑ

Try it

This should work for 10 bytes but there seems to be a bug in Japt's recursive replacement method.

e/(.)1/ÏÑ

Clean, 118 bytes

import StdEnv,Data.List

$[a,b:t]|a==b=[1,(a*2)rem 10]%(1-a/5,1)++ $t=[a: $[b:t]]

$l=l

limit o iterate$o map digitToInt

Try it online!

Takes the first repeated value (limit) from the infinite list of applications (iterate) of a lambda performing a single step of the collapsing process. Input taken as a [Char].

Red, 84 83 80 bytes

func[n][if parse s: form n[to some change[copy d skip d](2 * do d)to end][f s]s]

Try it online!

Returns the nth term of the sequence.

Explanation:

Red

f: func [ n ] [

    if parse s: form n [  ; parse the input converted to a string

        to some change [  ; find and change one or more

            copy d skip   ; digit (in fact any character, no predefined character classes)

            d             ; followed by itself

        ] (2 * do d)      ; with its doubled numeric value 

        to end            ; go to the end of the string

    ] [ f s ]             ; call the function with the altered string if parse returned true

    s                     ; finally return the string 

]

Wolfram Language 108 bytes

ToExpression[""<>ToString/@Total/@Flatten[Partition[#,UpTo@2]&/@Split@IntegerDigits@#,1]]&~FixedPoint~#&

Explanation

IntegerDigits transforms the input number into a list of its digits.

Split groups consecutive repeated digits.

Partition[#, UpTo@2]&/@ breaks runs of like digits into lists of, at most, lengths of 2.

Flatten[...,1] eliminates occasional overly-nested braces--e.g., {{2,2}} becomes {2,2}

Total/@ sums totals of paired digits. Isolated digits need not be summed.

ToString converts the totals (and isolated digits) to strings.

""<> joins all the strings in the list.

ToExpression converts the outcome to an integer.

...~FixedPoint~#& applies the function until the result ceases to change.

C# (Visual C# Interactive Compiler), 113 bytes

s=>{var t=s;do{s=t;t="";for(int i=0;i<s.Length;)t+=(s[i]-48)*(s[i++]!=(s+0)[i]?1:2*++i/i);}while(t!=s);return t;}

Try it online!

HUGE credit to @ASCIIOnly for golfing ~30 ;) At first we were both posting updates simultaneously, but at some point he clearly went to town!

Less golfed code...

// s is the input as a string

s=>{

  // t is another string used

  // to hold intermediate results

  var t=s;

  // the algorithm repeatedly

  // processes s and saves the

  // result to t

  do{

    // copy the last result to s

    // and blank out t

    s=t;

    t="";

    // iterate over s

    for(int i=0;i<s.Length;)

      // append either 1 or 2 times

      // the current digit to t

      t+=(s[i]-48)*

        // compare the current digit

        // to the next digit. to prevent

        // an out-of-bounds exception,

        // append a 0 to s which either

        // gets ignored or collapses

        // to 0

        (s[i++]!=(s+0)[i]

          // if they are different, then

          // the multiplier is 1

          ?1

          // if they are the same, then

          // the multiplier is 2, and we

          // have to increment i

          :2*++i/i);

  }

  // continue this until the input

  // and output are the same

  while(t!=s);

  return t;

}