I agree with you that $NC$ is not the best way to characterize efficient parallel algorithms.
Indeed, by definition NC also includes lots of problems which are not efficiently parallelizable. A common example is parallel binary search. The problem arises because parallel binary search has polylogarithmic time complexity even for $p = 1$. Any sequential algorithm requiring at most logarithmic time in the worst case is in $NC$ regardless of its parallel feasibility.
But wait, there is more.
$NC$ algorithms assume parallel machines with a polynomial number of processors to solve in polylogarithmic time moderately sized problems. However, in practice we use moderately sized machines (in terms of processors) to solve large problems. The number of processor tends to be sub polynomial, even sublinear.
Finally, there are problems in $P$ with sublinear parallel time $O(n^\epsilon), 0 < \epsilon < 1$.Therefore, these problems do not belong to $NC$. Now, sublinear functions may have a relevant asymptotic behavior only for impractically large values of $n$, and may be instead much less progressive for practical values of $n$. As an example, $\sqrt n < \lg^3 n$ for $n \leq 0.5 \times 10^9$. It follows that sublinear parallel time algorithms may run faster than $NC$ algorithms.
In one of the answer, it has been observed that "In practice, this means that we can prepare a computer with more memory as the input size grows, which is how we usually use computers in the real world. NC models an analogous situation in parallel computation".
I partially agree with this point of view. We buy a new parallel computer with more memory when an older supercomputer is decommissioned also because DRAM chips are less expensive upon time and to somewhat balance the parallel computer with regard to its main components (processors, memory, interconnect etc).
However, since memory is a finite resource, there has been a lot of research about using it efficiently, without requiring adding more memory to a supercomputer to solve larger instances of a problem. For instance, Sun and Ni proposed the notion of memory-bounded speedup, and Quinn proposed the so-called scalability function that measures how the amount of memory per processor must grow in order to maintain a constant level of efficiency. In general, since parallel overhead increases when the number of processors increases, we maintain efficiency increasing the size of the problem being solved. But the maximum problem size is limited by the amount of main memory (which is linear in $p$). The scalability function uses the isoefficiency function and another function which denotes the amount of memory required to store a problem of size $n$ to determine how the amount of memory per processor must grow in order to maintain a constant level of efficiency. When this function is a constant, the parallel algorithm is perfectly scalable (from the use of memory perspective). While memory is available, it is possible to maintain the same level of efficiency by increasing the problem size. However, since the memory used per processor increases linearly with $p$, at some point this value will reach the memory capacity of the system. Efficiency cannot be maintained when the number of processors increases beyond this point.
Therefore, it is increasingly important to design memory scalable parallel algorithms, since these are practical for large problems.
A final note on scaling down of parallel algorithms. This only make sense if the parallel algorithm we want to scale down is cost-optimal. Scaling down a cost optimal algorithm still produces a fast (if slower than the original) algorithm. But scaling down a non cost-optimal algorithm may lead to a parallel algorithm which is slower than the best sequential run time (consider scaling down an $n^3$ processor constant time sorting algorithm to $n$ processors).
The degree to which cost-optimality is missed impacts upon the range of problem and machine sizes over which an algorithm is useful and is well described in the textbook by Grama, Gupta, Karypis and Kumar.