 A+
I can't find bifunctor analog of fmap.
Explanation:
Functor for objects  datatype constructor. Type  a > f a
Functor for functions  fmap
. Type  (a > b) > (fa > fb)
Bifunctor for objects  result of bimap f g
, where f :: (a > a')
, g :: (b > b')
. Type  p a b > p a' b'
Bifunctor for functions  ?. Type  p (a > b) (c > d) > p (a' > b') (c' > d')
Here is why I think bifunctor have such type (am I right?) with some example
UPDATE
UPDATE2
p (a > b) (c > d) > p (a' > b') (c' > d')
in the image above is morphism from bifunctor to bifunctor, and also profunctor
Functor for objects  datatype constructor. Type 
a > f a
Functor for functions 
fmap
. Type (a > b) > (fa > fb)
Although this makes broadly sense, it is important to realise that the arrows above have three different meanings.
Functor for objects  datatype constructor. Type 
a ⟼ f a
Functor for functions 
fmap
. Type (a ⟿ b) ⟶ (f a ⟿ f b)
where
⟼
is a typelevel “mapsto symbol” that associates the typea
with a typef a
. This does not have anything to do with valuelevel functions whose domain isa
and codomainf a
. (Those are found in applicatives/monads, but that's a different story.)⟿
is a type constructor for some morphism. In the Hask category, those morphisms happen to be Haskell functions, but that's just a special case.⟶
is an actual functiontype constructor.
You may for now forget about the distinction between the latter two, but ⟼
and ⟶
are really quite different conceptually^{†}. Basically, ⟼
is like the arrow you write in a lambda
Maybe :: Type > Type Maybe = /a ⟼ Maybe a
whereas ⟶
is just a way to express that you're abstracting over functionthings.
Another related thing that might not be clear is that the objects you're talking about are Haskell types. Not values (as OO objects are).
So, I would phrase the listing you gave above thus:

Functor
 for objects: datatype constructor. Kind
Type > Type
, mappingassociationa ⟼ f a
.  for morphisms:
fmap
. Type:(a > b) > (f a > f b)
.
 for objects: datatype constructor. Kind

Bifunctor
 for objects: datatype constructor. Kind
Type×Type > Type
, or curriedType > Type > Type
, mappingassociationa ⟼ b ⟼ p a b
.  for morphisms:
bimap
. Type:(a > b) > (α > β) > p a α > p b β
.
 for objects: datatype constructor. Kind
^{†}_{Actually, Haskell does not have ⟼ or what you wrote with a > f a. This would be a typelevel lambda, but typelevel functions can actually only be expressed as type families, i.e. the closest you could get to expressing a ⟼ f a is type instance Functored a = f a.}