JavaScript (ES6),  62 58  49 bytes

f=a=>+a?a:[...f(a.map(n=>a-(a=n),a=a.shift())),a]

Try it online!

Commented

f = a =>                // f = recursive function taking the input list a

  +a ?                  // if a consists of a single positive integer:

    a                   //   stop recursion and return a

  :                     // else:

    [                   //   build an array consisting of:

      ...f(             //     1) all entries generated by a recursive call to f:

        a.map(n =>      //       for each value n in a:

          a - (a = n),  //         yield the difference between the previous value and n

                        //         and update a to n

          a = a.shift() //         start by removing the first element and saving it in a

        )               //       end of map()

      ),                //     end of recursive call

      a                 //     2) followed by the last entry from a

    ]                   //   end of array

Jelly, 6 bytes

ṚIƬZḢṚ

A monadic Link accepting a list of integers which yields a list of integers.

Try it online!

How?

Builds the whole triangle then extracts the required elements.

ṚIƬZḢṚ - Link: list of integers          e.g.  [84,42,21,10,2]

Ṛ      - reverse                               [2,10,21,42,84]

  Ƭ    - collect & apply until a fixed point:

 I     -   incremental differences            [[2,10,21,42,84],[8,11,21,42],[3,10,21],[7,11],[4],]

   Z   - transpose                            [[2,8,3,7,4],[10,11,10,11],[21,21,21],[42,42],[84]]

    Ḣ  - head                                  [2,8,3,7,4]

     Ṛ - reverse                               [4,7,3,8,2]

MathGolf, 14 11 bytes

xÆ‼├│?;∟;]x

Try it online!

Explanation

x             reverse int/array/string

 Æ     ∟      do while true without popping using 5 operators

  ‼           apply next 2 operators to TOS

   ├          pop from left of list

    │         get differences of list

     ?        rot3

      ;       discard TOS (removes rest from ├ command)

              loop ends here

        ;     discard TOS (removes empty array from stack)

         ]    wrap stack in array

          x   reverse array

Python 2, 78 bytes

lambda n,*a:R(lambda r,v:R(lambda x,w:x+[w-x[-1]],r,[v]),a,[n])[::-1]

R=reduce

Try it online!

R, 55 bytes

y=x=scan();for(i in sum(1|x):2-1)y[i]=(x=-diff(x))[i];y

Try it online!

Javascript (ES6), 127 bytes

f=a=>{for(e=[a],a=[a[l=a.length-1]],i=0;i<l;i++){for(e.push(g=),j=-1;j<l;)g.push(e[i][j]-e[i][++j]);r.unshift(g[j])}return r}

Original code

function f(a){

  var e=[a];

  var r=[a[a.length-1]];

  for (var i=1;i<a.length;i++){

    var g=;

    for (var j=0;j<a.length;j++){

      g.push(e[i-1][j-1]-e[i-1][j]);

    }

    e.push(g);

    r.unshift(g[j-1]);

  }

  return r;

}

Oh, I lost like... a lot... to the previous answer...

TI-BASIC, 54 bytes

Ans→L₁:dim(L₁→dim(L₂:While 1-Ans:L₁(Ans→L₂(Ans:-ΔList(L₁→L₁:dim(Ans:End:L₁(Ans→L₂(Ans:L₂

Input is the list of the right side of the triangle in Ans, as is described in the challenge.

Output is the top row of said triangle.

Examples:

{5,2,1

         {5 2 1}

prgmCDGF19

         {2 1 1}

{84,42,21,10,2

 {84 42 21 10 2}

prgmCDGF19

     {4 7 3 8 2}

Explanation:

This solution abuses the fact that the triangle formed using the right side of the triangle as the start ends up being the change in each element.

In other words,

2 1 1

 3 2

  5

becomes:

5 2 1

 3 1

  2

Thus, the resulting list is the right side of this new triangle, which can be formed by setting the last element to the index of its parent list's length in the resulting list.

Ans→L₁          ;store the input list in L₁

dim(L₁→dim(L₂   ;set the length of L₂ to the length of L₁

While 1-Ans    ;while the L₁'s length is not 1

L₁(Ans→L₂(Ans   ;set the last element of L₁ to the corresponding index in L₂

-ΔList(L₁→L₁    ;get the change in each element, then negate

               ; (elements are in descending order so the change in each

               ;  element will be negative)

               ; and store the resulting list in L₁

dim(Ans        ;leave the length of L₁ in "Ans"

End

L₁(Ans→L₂(Ans   ;set the element again

               ; (needed for final step)

L₂              ;leave L₂ in "Ans"

               ;implicit print of "Ans"

Note: TI-BASIC is a tokenized language. Character count does not equal byte count.