Are there alternatives to using polynomials in defining the different notions of efficient computation?
From the very beginning $P$ has drawn flak for allowing high degree polynomials to count as efficient (Edmonds essentially introduced $P$ to argue that his $O(n^4)$ matching algorithm should be considered efficient, but for computers in 1965 $O(n^4)$ was definitely not efficient), but there are very good reasons that the definition has stuck:


Polynomials have nice closure properties.  If $O(n)$ is efficient, and we allow an efficient algorithm to call an efficient subroutine a reasonable number of times, we are forced to conclude that $O(n^2)$ is efficient too, and iterating this reasoning leads us to conclude that $O(n^c)$ is efficient for all $c$ if we want to avoid a totally arbitrary cutoff.
$P$ is robust to changes in the underlying model of computation.  Complexity theory is about what problems are solvable in some reasonable model of computation.  There are a huge variety of equivalent models of computation that can simulate one another in polynomial time (Turing machines, register machines, stack machines, and other stranger models) and tons of variations (how many tapes does your Turing machine have?  How many states?), and we have no real reason to favor one over another.  If we design an algorithm for a RAM but need to preserve our definition of efficient from model to model, then we need to allow polynomial overhead for simulation.  Aliens may well have computer totally different from anything we have imagined, but their definition of $P$ would be the same.
$P$ is robust to technological advancement.  History has shown that computer science research that is not future-proof will quickly lose its relevance.  Over time, as computing power has increased, the definition of "truly efficient" has expanded to include larger polynomials, but $P$ has remained relevant.
In practice, problems requiring high degree polynomials are actually rarely an issue.  Generally, the difficult step is getting from exponential time to some polynomial, and once we have an algorithm in $P$ it is relatively easy to reduce the degree to something small.  There is an old joke that I have heard in several talks: "every time someone proves a problem is in $P$ Bob Tarjan makes it linear."