So ... I've been doing a little research. What follows is a little history lesson for those interested. :) Skip to the conclusion at the bottom if you're only interested in the answer.
SIMULA 67, the first object-oriented programming language defines keywords as class, object, call by reference, call by value and virtual.
SIMULA's inheritance system was originally known by a different name, concatenation (and later known as prefixing), referring to the fact that code of supertypes was copied and 'concatenated' with the code of subtypes. Later another form of inheritance system emerged, delegation, where calls are delegated by reference to the correct type.
Virtual most likely refers to the process which needs to be performed to dispatch a call to the correct implementation by using a virtual method table. It's virtual as compared to a fixed/concrete implementation.
Niklaus Wirth, writes about a concept defined as Stepwise Refinement. It basicly explains how to divide a program in partial solutions on which can be extended.
This is the earliest paper I found which coins the term abstract data types by Barbara Liskov.
An abstract data type defines a class of abstract objects which is completely characterized by the operations available on those objects. This means that an abstract type can be defined by defining the characterizing operations for that type. When a programmer makes use of an abstract data object, he is concerned only with the behavior which that object exhibits but not with any details of how that behavior is achieved by means of an implementation.
This paper also defines an operation cluster which seems to specify what we now know as an interface.
Interesting scientific terminology (paper from 1996):
Inheritance: a more low-level mechanism by which objects or classes can share behavior or data.
Subtyping: expresses conceptual specialization. A specific form of inheritance, also called interface inheritance.
Abstraction principles: The process of organizing our knowledge of an application domain into hierarchical rankings of orderings of abstractions, in order to obtain a better understanding of the phenomena in concern.
Partially implemented abstractions: abstractions whose definitions have purposely been left incomplete.
Abstract classes: Specific term for a partially implemented class in object-oriented systems.
Nonstrict inheritance: Allows operations to be redefined (or even removed) in subclasses.
Strict inheritance: Behaviorally compatible inheritance.
Abstract class is the most general term to use in object-oriented systems. It seems pure and non-pure virtual functions only originate from C++. For example, this interview with Stroustrup makes it seem he invented the terms. Scientific papers use more general terminology.
Virtual originates from SIMULA, which causes it's usage to be widespread, but it isn't a general term. It already defines implementation details. Speaking in terms of types of inheritance is more appropriate. Non-virtual by default corresponds to strict inheritance by default, while virtual by default corresponds to nonstrict inheritance.
Anyone interested in adjusting the wikipedia entry? :)