R, 39 33 30 bytes

c(a<-scan(),setdiff(a:a[2],a))

Try it online!

Thanks for saved bytes to user2390246 and J.Doe.

05AB1E, 4 bytes

Ÿ¦¨«

Try it online!

Explanation

 Ÿ # inclusive range [a ... b]
 ¦¨ # remove the first and last element
 « # append to input

Python 3, 52 48 47 42 bytes

lambda a,b:[a,b,*range(a,b,(a<b)*2-1)[1:]]

Try it online!

Combined former implementations.

Perl 6, 26 22 bytes

@_,

Try it online!

Explanation

 
 |@_, # Slip args a,b into result
 [...^](@_) # Reduce args a,b with ...^ operator, same as a...^b
 .skip # Skip first element
 | # Slip into result

Python 2 (Cython), 36 35 bytes

lambda x:x+range(*x,-cmp(*x)|1)[1:]

Thanks to @nwellnhof for golfing off 1 byte!

Try it online!

Python 2, 37 bytes

lambda x:x+range(*x+[-cmp(*x)|1])[1:]

Thanks to @JonasAusevicius for the port to CPython!

Try it online!

Python 3, 64 62 51 bytes

lambda a,b:[a,b]+[*range(a+1,b)]+[*range(a-1,b,-1)]

Try it online!

Python 2, 58 45 bytes

lambda a,b:[a,b]+range(a+1,b)+range(a-1,b,-1)

Try it online!

Python 2, 40 bytes

lambda x,y:[x,y]+range(x,y,-(y<x)|1)[1:]

Try it online!

Python 2, 47 41 bytes

lambda a,b:[a,b]+range(a,b,(a<b)*2-1)[1:]

Try it online!

Here's mine, now that a lot of other Python answers have been posted

_{-6 bytes, thanks to G B}

Japt, 8 bytes

cUr!õ kU

Try it here

 :Implicit input of array U
c :Concatenate
 Ur : Reduce U by
 !õ : Inclusive range
 kU : Remove all elements in original U

JavaScript (ES6), 51 bytes

Takes input as (a)(b).

a=>g=(b,c=b)=>(b+=b<a|-(b>a))-a?[...g(b,c),b]:[a,c]

Try it online!

Commented

a => // main function, taking a
 g = ( // g = recursive function
 b, // taking b
 c = b // we save a backup of the original value of b into c
 ) => //
 (b += // add to b:
 b < a | // +1 if b is less than a
 -(b > a) // -1 if b is greater than a
 ) // (or 0 if b = a)
 - a ? // if the updated value of b is not equal to a:
 [ // generate a new array:
 ...g(b, c), // prepend all values generated by a recursive call
 b // append the current value of b
 ] //
 : // else:
 [a, c] // stop recursion and return the first 2 values: a and c

Haskell, 34 bytes

a#b=a:b:[a+1..b-1]++[a-1,a-2..b+1]

Try it online!

Jelly, 4 bytes

,œ|r

Try it online!

How it works

,œ|r Main link. Left argument: a. Right argument: b

, Pair; yield [a, b].
 r Range; yield [a, ..., b].
 œ| Perform multiset union.

Octave, 45 bytes

@(a,b)[a b linspace(a,b,(t=abs(a-b))+1)(2:t)]

Try it online!

Java 10, 109 108 104 102 93 62 bytes

Using a space-delimited String:

b->a->var r=a+" "+b;for(;a<b?++a<b:--a>b;)r+=" "+a;return r;

Try it online.

Using a List:

b->a->var r=new java.util.Stack();for(r.add(a),r.add(b);a<b?++a<b:--a>b;)r.add(a);return r;

Try it online.

(a<b?++a<b:--a>b can be ++a<b||(a-=2)>b for the same byte-count: Try it online for the String or Try it online for the List.)

Old (109 108 104 102 101 bytes) answer using an array:

a->b->int s=a<b?1:-1,i=a!=b?(b-a)*s+1:2,r=new int[i];for(r[0]=a,r[1]=b;i>2;)r[--i]=b-=s;return r;

-7 bytes thanks to @nwellnhof.

Try it online.

Explanation:

a->b-> // Method with 2 int parameters & int-array return-type
 int s= // Step integer, starting at:
 a<b?1 // 1 if the first input is smaller than the second
 :-1; // -1 otherwise
 i= // Array-index integer, starting at:
 a!=b? // If the inputs aren't equal:
 (b-a)*s+1 // Set it to the absolute difference + 1
 : // Else:
 2, // Set it to 2
 r=new int[i]; // Result-array of that size
 for(r[0]=a, // Fill the first value with the first input
 r[1]=b; // And the second value with the second input
 i>2;) // Loop `i` downwards in the range [`i`,2):
 r[--i]= // Decrease `i` by 1 first with `--i`
 // Set the `i`'th array-value to:
 b-=s; // If the step integer is 1: decrease `b` by 1
 // If the step integer is -1: increase `b` by 1
 // And set the array-value to this modified `b`
 return r; // Return the result-array

Pyth, 5 bytes

+QtrF

Input is a two-element list, [input 1, input 2]. Try it online here, or verify all the test cases at once here.

+QtrFQ Implicit: Q=eval(input())
 Trailing Q inferred
 rFQ Generate range [input 1 - input 2)
 t Discard first element
+Q Prepend Q

Red, 75 bytes

func[a b][s: sign? d: b - a prin[a b]loop absolute d - s[prin[""a: a + s]]]

Try it online!

Clean, 49 bytes

import StdEnv
@a b=init[a,b:tl[a,a+sign(b-a)..b]]

Try it online!

Python 2, 52 47 41 bytes

lambda i,j:[i,j]+range(i,j,(i<j)*2-1)[1:]

Try it online!

-5 with thanks to @JoKing

-6 by slicing the first element from the range (idea stolen from and with credit to @TFeld)

Non-lambda version...

Python 2, 51 49 47 bytes

i,j=input();print[i,j]+range(i,j,(i<j)*2-1)[1:]

Try it online!

-2 with thanks to @JoKing

J, 26 bytes

,,[|.@]^:(>.)<.+1.i.@|@-

Try it online!

Explanation:

A dyadic verb (takes left and right argument)

 - subtracts the arguments
 |@ and finds the absolute value
 i.@ and makes a list 0..absolute difference
 1}. drops the fist element
 + adds to the entire list
 <. the smaller of the arguments
 |.@] reverses the list
 ^: only if
 [ the left argument
 (>improve this answer