get_next_smallest method bug in get_next_challenge solution

The get_next_smallest method in the solution for get_next_challenge is not implemented correctly. The problem is in the last line before the return:

```
# Clear all bits to the right of index
num &= ~((1 << index) - 1) <-- correctly clears the bits to right of index...
# Set bits starting from 0
num |= (1 << num_ones + 1) - 1 <-- but sets the bits 'right-aligned', when they should be 'left-aligned' up to the index of
the last zero before the non-trailing ones in the original number
```

E.g.

```
B = Bits()
num = 343434343
B.get_next_smallest(num)
```
Output:
`343434319`

The correct answer is 343434334

To illustrate what has went wrong:

343434343 is 10100011110000110010001100111 in binary.
343434319 is 10100011110000110010001001111 in binary.
343434334 is 10100011110000110010001011110 in binary.

So you can see that the incorrect answer is due to the 4 `1`s being added on the extreme right, rather than shifted up to the index of the last `0` before the non-trailing `1`s.

My solution that addresses this issue is:

```
def get_next_smallest(self, num):
if num is None:
raise TypeError('num cannot be None')
if num <= 0:
raise ValueError('num cannot be 0 or negative')

# handle numbers in which all bits are set - it is impossible to create a number less than
# this without using less set bits
if not (num + 1) & num:
return num

# create copy of num as we will need to shift it when counting 1s and 0s
num_copy = num
num_zeroes = 0
num_ones = 0

# count trailing 1s
while ((num_copy & 1) == 1):
num_ones += 1
num_copy >>= 1

# count number of 0s before first non-trailing 1
while (((num_copy & 1) == 0) and (num_copy != 0)):
num_zeroes += 1
num_copy >>= 1

# position of rightmost non-trailing one.
index = num_zeroes + num_ones

# clears from bit at index onwards
num &= ((~0) << (index + 1))

# Sequence of (num_ones + 1) ones
mask = (1 << (num_ones + 1)) - 1

# Shift the mask so the sequence of 1s is at the correct index, before applying it to num
num |= mask << (num_zeroes - 1)

return num

```