Why does only the earliest transaction matter for double spending? On page 2 of Bitcoin paper, it says:


  The problem of course is the payee can't verify that one of the owners
  did not  double-spend the coin. A common solution is to introduce a
  trusted central authority, or mint, that checks every transaction for
  double spending. After each transaction, the coin must be returned to
  the mint to issue a new coin,    and only coins issued directly from
  the mint are trusted not to be double-spent. The problem with this
  solution is that the fate of the entire money system depends on the
  company running the mint, with every transaction having to go through
  them, just like a bank.
  
  We need a way for the payee to know that the previous owners did not
  sign any earlier transactions.
  For our purposes, the earliest transaction is the one that counts, so we don't care about later attempts to double-spend. [emphasis added]
   The only way to confirm the absence of a transaction is to be aware
  of all transactions. In the mint based model, the mint was aware of
  all transactions and decided which arrived first. To accomplish this
  without a trusted party, transactions must be publicly announced [1],
  and we need a system for participants to agree on a single history of
  the order in which they were received. The payee needs proof that at
  the time of each transaction, the majority of nodes agreed it was the
  first received.


Why does only the earliest transaction matter for double spending? 
I thought that it would be latest as previous owner would have checked till that. But even that is flawed... We need to check all.

Is it because the coin is a list of transactions and only first one is not verified?
"Doublespend" refers to an attempt of spending the same funds twice. In Bitcoin specifically this occurs when a user publishes two transactions that are in conflict due to attempting to use the same unspent transaction output as input. Obviously, only one of the two transactions can be valid. 

Before Bitcoin was published, the solution to the doublespending problem was to designate a central actor that decided which of the two transactions would take precedence. The central actor would do this by announcing which of the two it had seen first.

The "first-seen" behavior was at first explicitly encoded in node behavior: nodes would not accept a conflicting transaction into their mempool (the temporary storage of unconfirmed transactions). However, this lead to the incorrect assumption that zero confirmation transactions could be reliable whereas actually the doublespending problem is solved by miners collecting transactions into blocks for confirmation. The blocks may only contain one of the two conflicting transactions, as otherwise the block is invalid. Thus, the blockchain specifies the precedence of transactions by converging on a common journal of the transactions without a central actor.

In the past months, we've seen the "first-seen" paradigm get softened significantly as doublespends (of unconfirmed transactions) have become more or less trivial due to the high demand for blockspace. As it is becoming common for users to update transactions with a higher fee (i.e. a doublespend), the "first seen" paradigm is falling out of use and being replaced by the defacto mechanism of "first-included". Assuming rational miner behavior selecting the most profitable transactions first, we will converge on a full replace-by-fee system eventually.

In other words, when the whitepaper describes the requirement for the Bitcoin system to create a convergent history with "first-seen", it describes a simplified situation that didn't account for the network dynamics of competition for blockspace. From today's perspective this should be understood as "first-confirmed".