JavaScript (ES6),  49 48  47 bytes

a=>a.sort(g=(p,q)=>p*q?g(p&p-1,q&q-1):!p-!q)[0]

Try it online!

How?

We .sort() the input list with a recursive function that, given p and q, clears the least significant bit set in each variable until one of them is equal to 0 (or both of them simultaneously). This allows to order the list from most to least bits set. We then return the first entry, i.e. the "bittiest" one.

Commented

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      p * q ?        //   if both p and q are ≠ 0:
        g(           //     do a recursive call:
          p & p - 1, //       clear the least significant bit set in p
          q & q - 1  //       clear the least significant bit set in q
        )            //     end of recursive call
      :              //   else:
        !p - !q      //     return +1 if p = 0 and q ≠ 0,
                     //         or -1 if p ≠ 0 and q = 0
                     //         or  0 if p = q = 0
  )[0]               // end of sort(); return the first entry

JavaScript (ES6),  49 48 47  45 bytes

Saved 2 bytes thanks to @user81655

a=>a.sort(g=(p,q)=>!p|-!q||g(p&p-1,q&q-1))[0]

Try it online!

How?

We .sort() the input list with a recursive function that, given p and q, clears the least significant bit set in each variable until one of them is equal to 0 (or both of them simultaneously). This allows to order the list from most to least bits set. We then return the first entry, i.e. the "bittiest" one.

Commented

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      !p | -!q       //     -> +1 if p = 0 and q ≠ 0,
                     //     or -1 if q = 0,
      ||             //     or  0 if p ≠ 0 and q ≠ 0, in which case ...
        g(           //     ... we do a recursive call: 
          p & p - 1, //       clear the least significant bit set in p
          q & q - 1  //       clear the least significant bit set in q
        )            //     end of recursive call
  )[0]               // end of sort(); return the first entry

JavaScript (ES6),  49 48  47 bytes

a=>a.sort(g=(p,q)=>p*q?g(p&p-1,q&q-1):!p-!q)[0]

Try it online!

Commented

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      p * q ?        //   if both p and q are ≠ 0:
        g(           //     do a recursive call:
          p & p - 1, //       remove the least significant bit set in p
          q & q - 1  //       remove the least significant bit set in q
        )            //     end of recursive call
      :              //   else:
        !p - !q      //     return +1 if p = 0 and q ≠ 0,
                     //         or -1 if p ≠ 0 and q = 0
                     //         or  0 if p = q = 0
  )[0]               // end of sort(); return the first entry

JavaScript (ES6),  49 48  47 bytes

a=>a.sort(g=(p,q)=>p*q?g(p&p-1,q&q-1):!p-!q)[0]

Try it online!

How?

We .sort() the input list with a recursive function that, given p and q, clears the least significant bit set in each variable until one of them is equal to 0 (or both of them simultaneously). This allows to order the list from most to least bits set. We then return the first entry, i.e. the "bittiest" one.

Commented

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      p * q ?        //   if both p and q are ≠ 0:
        g(           //     do a recursive call:
          p & p - 1, //       clear the least significant bit set in p
          q & q - 1  //       clear the least significant bit set in q
        )            //     end of recursive call
      :              //   else:
        !p - !q      //     return +1 if p = 0 and q ≠ 0,
                     //         or -1 if p ≠ 0 and q = 0
                     //         or  0 if p = q = 0
  )[0]               // end of sort(); return the first entry

JavaScript (ES6),  49  48 bytes

a=>a.sort(g=(p,q)=>p|q&&!p-!q+g(p&p-1,q&q-1))[0]

Try it online!

Commented

a =>               // a[] = input list
  a.sort(          // sort a[] ...
    g = (p, q) =>  // ... using the recursive function g:
      p | q &&     //   abort if both p and q are 0
      !p - !q +    //   increment the final result if p = 0 and q ≠ 0
                   //   decrement it if p ≠ 0 and q = 0
                   //   leave it unchanged if both p and q are ≠ 0
      g(           //   recursive call:
        p & p - 1, //     remove the least significant bit set in p
        q & q - 1  //     remove the least significant bit set in q
      )            //   end of recursive call
                   //   --> g(p, q) eventually returns popcnt(q) - popcnt(p)
  )[0]             // end of sort(); return the first entry

JavaScript (ES6),  49 48  47 bytes

a=>a.sort(g=(p,q)=>p*q?g(p&p-1,q&q-1):!p-!q)[0]

Try it online!

Commented

a =>                 // a[] = input list
  a.sort(            // sort a[] ...
    g = (p, q) =>    // ... using the recursive function g:
      p * q ?        //   if both p and q are ≠ 0:
        g(           //     do a recursive call:
          p & p - 1, //       remove the least significant bit set in p
          q & q - 1  //       remove the least significant bit set in q
        )            //     end of recursive call
      :              //   else:
        !p - !q      //     return +1 if p = 0 and q ≠ 0,
                     //         or -1 if p ≠ 0 and q = 0
                     //         or  0 if p = q = 0
  )[0]               // end of sort(); return the first entry