Support async pgsql connections and non-blocking queries

### New functions

Each of the new functions accepts a single `$connection` resource paramter.

  - `int pg_connect_poll(resource $connection)`
  - `resource pg_socket(resource $connection)`
  - `bool pg_consume_input(resource $connection)`
  - `mixed pg_flush(resource $connection)`

### Modified functions

The following functions now additionally return zero if the  underlying socket is set to non-blocking mode and the send operation does not complete immediately. Previously these functions returned only boolean values and blocked execution while polling until all data was sent:

  - `pg_send_execute`
  - `pg_send_prepare`
  - `pg_send_query`
  - `pg_send_query_params`

### New constants

Used with `pg_connect()` to initiate an asynchronous connection attempt:

  - `PGSQL_CONNECT_ASYNC`

Used with `pg_connection_status()` to determine the current state of an async connection attempt:

  - `PGSQL_CONNECTION_STARTED`
  - `PGSQL_CONNECTION_MADE`
  - `PGSQL_CONNECTION_AWAITING_RESPONSE`
  - `PGSQL_CONNECTION_AUTH_OK`
  - `PGSQL_CONNECTION_SSL_STARTUP`
  - `PGSQL_CONNECTION_SETENV`

Used with `pg_connect_poll()` to determine the result of an async connection attempt:

  - `PGSQL_POLLING_FAILED`
  - `PGSQL_POLLING_READING`
  - `PGSQL_POLLING_WRITING`
  - `PGSQL_POLLING_OK`
  - `PGSQL_POLLING_ACTIVE`

### Polling via returned `pg_socket()` stream

`pg_socket()` returns a read-only socket stream that may be cast to a file descriptor for select (and similar) polling operations. Blocking behavior of the pgsql connection socket can be controlled by calling `stream_set_blocking()` on the stream returned by `pg_socket()`.

### Backwards Compatibility

These changes have no BC ramifications. All existing code continues to work as before.


### Example Async Connect

```php
<?php
// Initiate async connect
if (!$db = pg_connect($conn_str, PGSQL_CONNECT_ASYNC)) {
    echo "pg_connect() error\n";
} elseif (pg_connection_status($db) === PGSQL_CONNECTION_BAD) {
    echo "pg_connect() error\n";
} elseif ($db_sock = pg_socket($db)) {
    stream_set_blocking($db_sock, FALSE);
} else {
    echo "pg_socket() error\n";
}

// Convenience methods for detecting readability/writability on the connection
$isReadable = function($stream, $timeout = 1) {
    $r = [$stream]; $w = []; $e = [];
    return (bool) stream_select($r, $w, $e, $timeout, 0);
};

$isWritable = function($stream, $timeout = 1) {
    $r = []; $w = [$stream]; $e = [];
    return (bool) stream_select($r, $w, $e, $timeout, 0);
};

// Poll until async connection is established
while (TRUE) {
    switch (pg_connect_poll($db)) {
        case PGSQL_POLLING_READING:
            if ($isReadable($db_sock)) { break 2; }
            break;
        case PGSQL_POLLING_WRITING:
            if ($isWritable($db_sock)) { break 2; }
            break;
        case PGSQL_POLLING_FAILED:
            die("Async connection failed\n");
        case PGSQL_POLLING_OK:
            echo "Async connection established\n";
            break 2;
    }
}
```

### Example Non-Blocking Query + Result

```php
<?php
// Connect; get pollable socket; set socket to non-blocking.
$db = pg_connect($conn_str);
$db_sock = pg_socket($db);
stream_set_blocking($db_sock, FALSE);

// Send query
$sendCompleted = pg_send_query($db, "SELECT * FROM ".$table_name.";");

// Manually flush send buffer if necessary.
if ($sendCompleted === TRUE) {
    echo "pg_send_query() complete\n";
} elseif ($sendCompleted === FALSE) {
    die("pg_send_query() error");
} elseif ($sendCompleted === 0) {
    // flush all remaining data
    while (TRUE) {
        $r = []; $w = [$db_sock]; $e = [];
        if (!stream_select($r, $w, $e, $sec=42, $usec=0)) {
            continue;
        }
        $flushCompleted = pg_flush($db);
        if ($flushCompleted === TRUE) {
            echo "All outbound data flushed\n";
            break;
        } elseif ($flushCompleted === 0) {
            echo "More data to send\n";
        } elseif ($flushCompleted === FALSE) {
            die("Flush failed");
        }
    }
}

// Poll for readability and consume the result
while (TRUE) {
    $r = [$db_sock]; $w = []; $e = [];
    if (!stream_select($r, $w, $e, $sec=42, $usec=0)) {
        continue;
    } elseif (!pg_consume_input($db)) {
        die("pg_consume_input() error");
    } elseif (!pg_connection_busy($db)) {
        echo "All inbound data consumed!\n";
        break;
    }
}

// We've now consumed the full result
$result = pg_get_result($db);
```