Inference in G-API

This PR introduces basic inference support to G-API.

Changes overview

Core G-API

• own::Mat has been extended with N-dimensions support. Continues
  mimicing to cv::Mat in this behavior. Added tests.
• GMatDesc now also supports dimensions in addition to a regular 2D
  size. A new constructor has been added to.
• cv::descr_of() overload for vector of Mats has been renamed to
  cv::descrs_of() (and I am still wondering if we actually need this
  function). A vector of Mats now is a valid host form for GArray<GMat>.
• Operations are extended with tags. By default, all our old regular
  kernels have empty tags (and are identified solely by kernel ID).
• Engine has been extended with backend-defined metadata resolution
  callbacks (see below).

On backend-specific outMeta

In our regular interface, an outMeta (defining formats operations's
of outputs given the inputs) is defined with the operation itself --
so it describes API contract and not a particular implementation.

Sometimes an operation can't fully describe its meta when it is
defined, and so backends can put their own methods to the graph once
there's a clarity.

Example: when we define a network as API entry, we're not certain
about its input/output formats (data type, dimensions, etc) until we
actually load the network. This loading happens on graph compilation
stage, not on the graph construction stage, and is defined by the
underlying engines which do the actual work.

New entities

Inference API

Inference API is represented by just two files:

• include/opencv2/gapi/infer.hpp
• src/api/ginfer.cpp

Header file is the most importand one, it defines two generic
operations: Infer and InferList, and an API to express networks we
use (G_API_NET() macro).

Once a user declares his network, it can be used to construct graphs.
Network's name (a macro parameter) is used as an operation tag (see
above) to distinguish between different infer calls in graph (note -
the operation itself is always the same).

Similar to kernels, scoring engines are specified in the form of
backend-specific network parameters which are then passed to G-API
as compilation arguments (as a Network package).

Since every inference backend's parameters may differ, but network
parameters are also tightly coupled with networks itselves,
backend-specific parameters are usually derivatives from the network
APIs. Networks (as types) are specified as template arguments to
universal backend-specific parameter structures so knowledge about
network and its backend combines in a single object.

A code is worth a thousand words so please review a test in this PR.

Inference backend (DLDT)

The above API is (as usual) just an interface which can be implemented
(multiple times). This PR introduces a basic DLDT/IE-based
implementation of the inference interface.

This backend implements the two universal inference kernels (Infer
and InferList) and provies a configuration API (see
gapi/infer/ie.hpp). It already supports automatic preprocessing with
Crop/Scale/CSC pipeline out-of-the-box. And yes, in this case G-API is
working from within a G-API. :)

Tests

So far tested with a DLDT Age/Gender model only. Model is taken from
DNN module's own test suite.

force_builders=Custom,Custom Win,Custom Mac
build_image:Custom=ubuntu-openvino-2019r2.0:16.04
build_image:Custom Win=openvino-2019r1
build_image:Custom Mac=openvino-2019r1
test_modules:Custom=gapi
test_modules:Custom Win=gapi
test_modules:Custom Mac=gapi
buildworker:Custom=linux-1
test_opencl:Custom=ON
test_bigdata:Custom=1
test_filter:Custom=*
build_gapi_standalone:Linux x64=ade-0.1.1d
build_gapi_standalone:Win64=ade-0.1.1d
build_gapi_standalone:Mac=ade-0.1.1d
build_gapi_standalone:Linux x64 Debug=ade-0.1.1d