Optimize none? and one? relation query methods to use LIMIT 1 and COUNT.

I was surprised to find out that relation's `none?` method was loading the entire collection as an array,
even if no block or limit was given. This contrasts how `any?` and `many?` work, which is to use `LIMIT 1` and `COUNT` respectively, if no block and limit is given.

IMO it's more natural to use `.none?` query rather than either `empty?` (because `empty?` is an Array method while `none?` is an Enumerable method and thus seems more suitable for a generic set such a a set of database rows). I therefore changed `none?` to follow the already existing behavior for `any?` and `many?`. 

I also implemented an optimized `one?` for similar reasons and for completion sake - just as me, others could be surprised that `one?` behaves differently than `any?` and `many?`, and I don't see a drawback to being consistent in providing an efficient implementation if possible.

This change applies to relations (e.g. `User.all`) as well as associations (e.g. `account.users`).

Before:

```ruby
users.none?
SELECT "users".* FROM "users"
 
users.one?
SELECT "users".* FROM "users"
```

After:

```ruby
users.none?
SELECT 1 AS one FROM "users" LIMIT 1

users.one?
SELECT COUNT(*) FROM "users"
```

`NullRelation` has been updated to short-curciut `none?` and `one?`, as it already does with `any?` and `many?`.

Also, improved method documentation a bit.

I added the (appropriately modified) same set of tests as present for `any?` and `many?` methods in `relations_test.rb` and `associations/has_many_association_test.rb` unit tests.

The database has changed since you did that test, so it's failing because now there are 3 clients...
I think you should rebase and change that test, because you are basing your test just in a quantity of data that could change over time on the test database... broking your test just because you forbidden the data to grow up...